idletime 0.1.2 → 0.2.0

package/dist/idletime.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "idletime",
-  version: "0.1.2",
+  version: "0.2.0",
   description: "Visual CLI for Codex focus, token burn, spikes, and idle time from local session logs.",
   author: "ParkerRex",
   main: "./dist/idletime.js",
@@ -46,10 +46,10 @@ var package_default = {
   sideEffects: false,
   scripts: {
     build: "bun run src/release/build-package.ts",
-    "check:release": "bun run typecheck && bun test && bun run qa && npm pack --dry-run",
+    "check:release": "bun run build && bun run typecheck && bun test && bun run qa && npm pack --dry-run",
     dev: "bun run src/cli/idletime-bin.ts",
     idletime: "bun run src/cli/idletime-bin.ts",
-    "pack:dry-run": "npm pack --dry-run",
+    "pack:dry-run": "bun run build && npm pack --dry-run",
     "publish:dry-run": "bun run build && bun publish --dry-run --access public",
     prepublishOnly: "bun run check:release",
     qa: "bun run qa:gaps && bun run qa:journeys",
@@ -64,6 +64,211 @@ var package_default = {
   }
 };
 
+// src/reporting/types.ts
+var jsonReportSchemaVersion = 1;
+
+// src/reporting/serialize-json-common.ts
+function stringifyJsonSnapshot(snapshot) {
+  return `${JSON.stringify(snapshot, null, 2)}
+`;
+}
+function serializeIsoTimestamp(timestamp) {
+  return timestamp.toISOString();
+}
+function serializeTimeInterval(interval) {
+  return {
+    start: serializeIsoTimestamp(interval.start),
+    end: serializeIsoTimestamp(interval.end)
+  };
+}
+function serializeReportWindow(window) {
+  return {
+    label: window.label,
+    start: serializeIsoTimestamp(window.start),
+    end: serializeIsoTimestamp(window.end),
+    timeZone: window.timeZone
+  };
+}
+function serializeSessionFilters(filters) {
+  return {
+    workspaceOnlyPrefix: filters.workspaceOnlyPrefix,
+    sessionKind: filters.sessionKind,
+    model: filters.model,
+    reasoningEffort: filters.reasoningEffort
+  };
+}
+function serializeActivityMetrics(metrics) {
+  return {
+    strictEngagementBlocks: metrics.strictEngagementBlocks.map(serializeTimeInterval),
+    directActivityBlocks: metrics.directActivityBlocks.map(serializeTimeInterval),
+    agentCoverageBlocks: metrics.agentCoverageBlocks.map(serializeTimeInterval),
+    agentOnlyBlocks: metrics.agentOnlyBlocks.map(serializeTimeInterval),
+    perAgentTaskBlocks: metrics.perAgentTaskBlocks.map((taskBlocks) => taskBlocks.map(serializeTimeInterval)),
+    strictEngagementMs: metrics.strictEngagementMs,
+    directActivityMs: metrics.directActivityMs,
+    agentCoverageMs: metrics.agentCoverageMs,
+    agentOnlyMs: metrics.agentOnlyMs,
+    cumulativeAgentMs: metrics.cumulativeAgentMs,
+    peakConcurrentAgents: metrics.peakConcurrentAgents
+  };
+}
+function serializeWakeWindowSummary(wakeWindowSummary) {
+  return {
+    wakeDurationMs: wakeWindowSummary.wakeDurationMs,
+    strictEngagementMs: wakeWindowSummary.strictEngagementMs,
+    directActivityMs: wakeWindowSummary.directActivityMs,
+    agentOnlyMs: wakeWindowSummary.agentOnlyMs,
+    awakeIdleMs: wakeWindowSummary.awakeIdleMs,
+    awakeIdlePercentage: wakeWindowSummary.awakeIdlePercentage,
+    longestIdleGapMs: wakeWindowSummary.longestIdleGapMs
+  };
+}
+
+// src/reporting/serialize-hourly-report.ts
+function serializeHourlyReportPayload(hourlyReport) {
+  return {
+    appliedFilters: serializeSessionFilters(hourlyReport.appliedFilters),
+    agentConcurrencySource: hourlyReport.agentConcurrencySource,
+    buckets: hourlyReport.buckets.map(serializeHourlyBucket),
+    hasWakeWindow: hourlyReport.hasWakeWindow,
+    idleCutoffMs: hourlyReport.idleCutoffMs,
+    maxValues: {
+      agentOnlyMs: hourlyReport.maxValues.agentOnlyMs,
+      directActivityMs: hourlyReport.maxValues.directActivityMs,
+      engagedMs: hourlyReport.maxValues.engagedMs,
+      practicalBurn: hourlyReport.maxValues.practicalBurn
+    },
+    window: serializeReportWindow(hourlyReport.window)
+  };
+}
+function serializeHourlySnapshot(input) {
+  const snapshot = {
+    schemaVersion: jsonReportSchemaVersion,
+    mode: "hourly",
+    generatedAt: input.generatedAt.toISOString(),
+    command: {
+      idleCutoffMs: input.command.idleCutoffMs,
+      filters: serializeSessionFilters(input.command.filters),
+      wakeWindow: input.command.wakeWindow ? { ...input.command.wakeWindow } : null
+    },
+    hourlyReport: serializeHourlyReportPayload(input.hourlyReport)
+  };
+  return stringifyJsonSnapshot(snapshot);
+}
+function serializeHourlyBucket(bucket) {
+  return {
+    start: serializeTimeInterval({
+      start: bucket.start,
+      end: bucket.end
+    }).start,
+    end: serializeTimeInterval({
+      start: bucket.start,
+      end: bucket.end
+    }).end,
+    agentOnlyMs: bucket.agentOnlyMs,
+    awakeIdleMs: bucket.awakeIdleMs,
+    directActivityMs: bucket.directActivityMs,
+    engagedMs: bucket.engagedMs,
+    peakConcurrentAgents: bucket.peakConcurrentAgents,
+    practicalBurn: bucket.practicalBurn,
+    rawTotalTokens: bucket.rawTotalTokens,
+    sessionCount: bucket.sessionCount
+  };
+}
+
+// src/reporting/serialize-live-report.ts
+function serializeLiveReportPayload(liveReport) {
+  return {
+    appliedFilters: serializeSessionFilters(liveReport.appliedFilters),
+    doneRecentCount: liveReport.doneRecentCount,
+    doneRecentWindowMs: liveReport.doneRecentWindowMs,
+    doneThisTurnCount: liveReport.doneThisTurnCount,
+    observedAt: serializeIsoTimestamp(liveReport.observedAt),
+    peakTodayCount: liveReport.peakTodayCount,
+    recentConcurrencyValues: [...liveReport.recentConcurrencyValues],
+    runningCount: liveReport.runningCount,
+    runningLocations: liveReport.runningLocations.map((location) => ({
+      cwd: location.cwd,
+      runningCount: location.runningCount
+    })),
+    waitingThreads: liveReport.waitingThreads.map((waitingThread) => ({
+      cwd: waitingThread.cwd,
+      sessionId: waitingThread.sessionId,
+      waitDurationMs: waitingThread.waitDurationMs
+    })),
+    waitingOnUserCount: liveReport.waitingOnUserCount,
+    waitingOnUserLocations: liveReport.waitingOnUserLocations.map((location) => ({
+      cwd: location.cwd,
+      waitingCount: location.waitingCount
+    })),
+    scope: liveReport.scope,
+    workspacePrefix: liveReport.workspacePrefix
+  };
+}
+function serializeLiveSnapshot(input) {
+  const snapshot = {
+    schemaVersion: jsonReportSchemaVersion,
+    mode: "live",
+    generatedAt: input.generatedAt.toISOString(),
+    command: {
+      filters: serializeSessionFilters(input.command.filters)
+    },
+    liveReport: serializeLiveReportPayload(input.liveReport)
+  };
+  return stringifyJsonSnapshot(snapshot);
+}
+
+// src/reporting/serialize-summary-report.ts
+function serializeSummarySnapshot(input) {
+  const snapshot = {
+    schemaVersion: jsonReportSchemaVersion,
+    mode: input.mode,
+    generatedAt: input.generatedAt.toISOString(),
+    command: {
+      idleCutoffMs: input.command.idleCutoffMs,
+      filters: serializeSessionFilters(input.command.filters),
+      groupBy: [...input.command.groupBy],
+      wakeWindow: input.command.wakeWindow ? { ...input.command.wakeWindow } : null
+    },
+    hourlyReport: input.hourlyReport ? serializeHourlyReportPayload(input.hourlyReport) : null,
+    summaryReport: serializeSummaryReportPayload(input.summaryReport)
+  };
+  return stringifyJsonSnapshot(snapshot);
+}
+function serializeSummaryReportPayload(summaryReport) {
+  return {
+    activityWindow: summaryReport.activityWindow ? serializeTimeInterval(summaryReport.activityWindow) : null,
+    appliedFilters: serializeSessionFilters(summaryReport.appliedFilters),
+    comparisonCutoffMs: summaryReport.comparisonCutoffMs,
+    comparisonMetrics: serializeActivityMetrics(summaryReport.comparisonMetrics),
+    directTokenTotals: { ...summaryReport.directTokenTotals },
+    groupBreakdowns: summaryReport.groupBreakdowns.map(serializeSummaryBreakdown),
+    idleCutoffMs: summaryReport.idleCutoffMs,
+    metrics: serializeActivityMetrics(summaryReport.metrics),
+    sessionCounts: { ...summaryReport.sessionCounts },
+    tokenTotals: { ...summaryReport.tokenTotals },
+    wakeSummary: summaryReport.wakeSummary ? serializeWakeWindowSummary(summaryReport.wakeSummary) : null,
+    window: serializeReportWindow(summaryReport.window)
+  };
+}
+function serializeSummaryBreakdown(breakdown) {
+  return {
+    dimension: breakdown.dimension,
+    rows: breakdown.rows.map(serializeSummaryBreakdownRow)
+  };
+}
+function serializeSummaryBreakdownRow(row) {
+  return {
+    key: row.key,
+    sessionCount: row.sessionCount,
+    directActivityMs: row.directActivityMs,
+    agentCoverageMs: row.agentCoverageMs,
+    cumulativeAgentMs: row.cumulativeAgentMs,
+    practicalBurn: row.practicalBurn,
+    rawTotalTokens: row.rawTotalTokens
+  };
+}
+
 // src/report-window/parse-duration.ts
 var durationPattern = /^(\d+)(m|h|d)$/;
 function parseDurationToMs(durationText) {
@@ -313,6 +518,7 @@ function parseIdletimeCommand(argv) {
   let helpRequested = false;
   let hourlyWindowMs = defaultWindowMs;
   let idleCutoffMs = defaultIdleCutoffMs;
+  let outputFormat = "text";
   let shareMode = false;
   let versionRequested = false;
   let wakeWindow = null;
@@ -329,6 +535,10 @@ function parseIdletimeCommand(argv) {
       versionRequested = true;
       continue;
     }
+    if (argument === "--json") {
+      outputFormat = "json";
+      continue;
+    }
     if (argument === "--window") {
       hourlyWindowMs = parseDurationToMs(readFlagValue(argument, args));
       continue;
@@ -341,6 +551,10 @@ function parseIdletimeCommand(argv) {
       filters.workspaceOnlyPrefix = readFlagValue(argument, args);
       continue;
     }
+    if (argument === "--global") {
+      filters.workspaceOnlyPrefix = null;
+      continue;
+    }
     if (argument === "--session-kind") {
       filters.sessionKind = parseSessionKind(readFlagValue(argument, args));
       continue;
@@ -373,6 +587,18 @@ function parseIdletimeCommand(argv) {
     }
     throw new Error(`Unknown argument "${argument}".`);
   }
+  if (!helpRequested && !versionRequested) {
+    validateParsedCommand({
+      commandName,
+      filters,
+      groupBy,
+      hourlyWindowMs,
+      idleCutoffMs,
+      outputFormat,
+      shareMode,
+      wakeWindow
+    });
+  }
   return {
     commandName,
     filters,
@@ -380,6 +606,7 @@ function parseIdletimeCommand(argv) {
     helpRequested,
     hourlyWindowMs,
     idleCutoffMs,
+    outputFormat,
     shareMode,
     versionRequested,
     wakeWindow
@@ -391,13 +618,15 @@ function renderHelpText() {
     "Track Codex focus, activity, idle time, and token burn from local session logs.",
     "",
     "Usage:",
-    "  idletime [last24h|today|hourly] [options]",
-    "  inside this repo: bun run idletime [last24h|today|hourly] [options]",
+    "  idletime [last24h|today|hourly|live|refresh-bests] [options]",
+    "  inside this repo: bun run idletime [last24h|today|hourly|live|refresh-bests] [options]",
     "",
     "Modes:",
     "  last24h   default. visual trailing-24h dashboard with rhythm, spikes, and stats",
     "  today     local-midnight-to-now summary for the current day",
     "  hourly    trailing-window chart plus the detailed per-hour table",
+    "  live      repainting task scoreboard; global by default",
+    "  refresh-bests  full-history best-metrics refresh; updates BEST records",
     "",
     "How To Read The Dashboard:",
     "  focus     strict engagement inferred from actual user_message arrivals",
@@ -408,7 +637,9 @@ function renderHelpText() {
     "",
     "Options:",
     "  --window <24h>          trailing window for hourly or last24h",
+    "  --json                  print a machine-readable JSON snapshot",
     "  --idle-cutoff <15m>     how long activity stays live after the last event",
+    "  --global                clear workspace scoping and read all sessions",
     "  --workspace-only <dir>  include only sessions whose cwd starts with this path",
     "  --session-kind <kind>   direct or subagent",
     "  --model <name>          include only one primary model",
@@ -424,12 +655,59 @@ function renderHelpText() {
     "  idletime --wake 07:45-23:30 --share",
     "  idletime today --workspace-only /path/to/demo-workspace",
     "  idletime hourly --window 24h --workspace-only /path/to/demo-workspace",
+    "  idletime live",
+    "  idletime live --workspace-only /path/to/demo-workspace",
+    "  idletime --json",
+    "  idletime live --json",
+    "  idletime refresh-bests",
     "  idletime --version"
   ].join(`
 `);
 }
 function isCommandName(value) {
-  return value === "hourly" || value === "last24h" || value === "today";
+  return value === "hourly" || value === "last24h" || value === "live" || value === "refresh-bests" || value === "today";
+}
+function validateParsedCommand(input) {
+  if (input.outputFormat === "json" && input.shareMode) {
+    throw new Error("--share is only supported for human-readable output.");
+  }
+  if (input.commandName !== "refresh-bests") {
+    return;
+  }
+  const unsupportedFlags = [];
+  if (input.outputFormat !== "text") {
+    unsupportedFlags.push("--json");
+  }
+  if (input.shareMode) {
+    unsupportedFlags.push("--share");
+  }
+  if (input.hourlyWindowMs !== defaultWindowMs) {
+    unsupportedFlags.push("--window");
+  }
+  if (input.idleCutoffMs !== defaultIdleCutoffMs) {
+    unsupportedFlags.push("--idle-cutoff");
+  }
+  if (input.wakeWindow) {
+    unsupportedFlags.push("--wake");
+  }
+  if (input.groupBy.length > 0) {
+    unsupportedFlags.push("--group-by");
+  }
+  if (input.filters.workspaceOnlyPrefix) {
+    unsupportedFlags.push("--workspace-only");
+  }
+  if (input.filters.sessionKind) {
+    unsupportedFlags.push("--session-kind");
+  }
+  if (input.filters.model) {
+    unsupportedFlags.push("--model");
+  }
+  if (input.filters.reasoningEffort) {
+    unsupportedFlags.push("--effort");
+  }
+  if (unsupportedFlags.length > 0) {
+    throw new Error(`refresh-bests does not support ${unsupportedFlags.join(", ")}.`);
+  }
 }
 function parseSessionKind(sessionKindText) {
   if (sessionKindText === "direct" || sessionKindText === "subagent") {
@@ -674,6 +952,145 @@ function resolvePrimaryReasoningEffort(turnAttributions) {
   return null;
 }
 
+// src/codex-session-log/task-windows.ts
+var defaultTaskWindowStaleAfterMs = 5 * 60000;
+var standardTaskWindowStaleAfterMs = 2 * 60000;
+function extractTaskWindows(records, options) {
+  const turnContexts = new Map;
+  const activeTaskWindows = new Map;
+  const orderedTaskWindows = [];
+  let currentTurnId = null;
+  for (const record of records) {
+    if (record.type === "session_meta") {
+      continue;
+    }
+    if (record.type === "turn_context") {
+      const payload2 = expectObject(record.payload, "turn_context.payload");
+      const turnId = readString(payload2, "turn_id", "turn_context.payload");
+      const turnContext = {
+        cwd: readString(payload2, "cwd", "turn_context.payload"),
+        model: readOptionalString(payload2, "model"),
+        reasoningEffort: readOptionalString(payload2, "effort")
+      };
+      turnContexts.set(turnId, turnContext);
+      const activeTaskWindow = activeTaskWindows.get(turnId);
+      if (activeTaskWindow) {
+        activeTaskWindow.cwd = turnContext.cwd;
+        activeTaskWindow.model = turnContext.model;
+        activeTaskWindow.reasoningEffort = turnContext.reasoningEffort;
+        activeTaskWindow.lastActivityAt = record.timestamp;
+        currentTurnId = turnId;
+      }
+      continue;
+    }
+    if (record.type !== "event_msg") {
+      touchCurrentTaskWindow(activeTaskWindows, currentTurnId, record.timestamp);
+      continue;
+    }
+    const payload = expectObject(record.payload, "event_msg.payload");
+    const eventType = readOptionalString(payload, "type");
+    if (eventType === "task_started") {
+      const turnId = readString(payload, "turn_id", "event_msg.payload");
+      const turnContext = turnContexts.get(turnId);
+      const taskWindow = {
+        completedAt: null,
+        cwd: turnContext?.cwd ?? options.cwd,
+        lastActivityAt: record.timestamp,
+        model: turnContext?.model ?? null,
+        reasoningEffort: turnContext?.reasoningEffort ?? null,
+        startedAt: record.timestamp,
+        turnId
+      };
+      activeTaskWindows.set(turnId, taskWindow);
+      orderedTaskWindows.push(taskWindow);
+      currentTurnId = turnId;
+      continue;
+    }
+    if (eventType === "task_complete") {
+      const turnId = readString(payload, "turn_id", "event_msg.payload");
+      const activeTaskWindow = activeTaskWindows.get(turnId) ?? createFallbackTaskWindow(record.timestamp, turnId, turnContexts.get(turnId), options.cwd);
+      if (!activeTaskWindows.has(turnId)) {
+        orderedTaskWindows.push(activeTaskWindow);
+      }
+      activeTaskWindow.lastActivityAt = record.timestamp;
+      activeTaskWindow.completedAt = record.timestamp;
+      activeTaskWindows.delete(turnId);
+      currentTurnId = currentTurnId === turnId ? null : currentTurnId;
+      continue;
+    }
+    const eventTurnId = readOptionalString(payload, "turn_id");
+    if (eventTurnId && activeTaskWindows.has(eventTurnId)) {
+      touchCurrentTaskWindow(activeTaskWindows, eventTurnId, record.timestamp);
+      currentTurnId = eventTurnId;
+      continue;
+    }
+    touchCurrentTaskWindow(activeTaskWindows, currentTurnId, record.timestamp);
+  }
+  return orderedTaskWindows.map((taskWindow, taskWindowIndex) => ({
+    taskId: `${options.sessionId}:${taskWindow.turnId}:${taskWindowIndex}`,
+    sessionId: options.sessionId,
+    parentSessionId: options.parentSessionId,
+    sessionKind: options.sessionKind,
+    cwd: taskWindow.cwd,
+    turnId: taskWindow.turnId,
+    model: taskWindow.model,
+    reasoningEffort: taskWindow.reasoningEffort,
+    startedAt: taskWindow.startedAt,
+    lastActivityAt: taskWindow.lastActivityAt,
+    completedAt: taskWindow.completedAt,
+    staleAfterMs: resolveTaskWindowStaleAfterMs(taskWindow.reasoningEffort)
+  }));
+}
+function buildTaskWindowInterval(taskWindow, observedAt) {
+  const intervalEnd = resolveTaskWindowEnd(taskWindow, observedAt);
+  if (intervalEnd.getTime() <= taskWindow.startedAt.getTime()) {
+    return null;
+  }
+  return {
+    start: taskWindow.startedAt,
+    end: intervalEnd
+  };
+}
+function isTaskWindowRunning(taskWindow, observedAt) {
+  return taskWindow.completedAt === null && taskWindow.lastActivityAt.getTime() + taskWindow.staleAfterMs > observedAt.getTime();
+}
+function isTaskWindowCompletedBetween(taskWindow, windowStart, windowEnd) {
+  if (!taskWindow.completedAt) {
+    return false;
+  }
+  return taskWindow.completedAt.getTime() > windowStart.getTime() && taskWindow.completedAt.getTime() <= windowEnd.getTime();
+}
+function resolveTaskWindowEnd(taskWindow, observedAt) {
+  if (taskWindow.completedAt) {
+    return taskWindow.completedAt;
+  }
+  const staleDeadline = new Date(taskWindow.lastActivityAt.getTime() + taskWindow.staleAfterMs);
+  return staleDeadline.getTime() < observedAt.getTime() ? staleDeadline : observedAt;
+}
+function resolveTaskWindowStaleAfterMs(reasoningEffort) {
+  return reasoningEffort === "medium" || reasoningEffort === "high" ? standardTaskWindowStaleAfterMs : defaultTaskWindowStaleAfterMs;
+}
+function createFallbackTaskWindow(timestamp, turnId, turnContext, defaultCwd) {
+  return {
+    completedAt: null,
+    cwd: turnContext?.cwd ?? defaultCwd,
+    lastActivityAt: timestamp,
+    model: turnContext?.model ?? null,
+    reasoningEffort: turnContext?.reasoningEffort ?? null,
+    startedAt: timestamp,
+    turnId
+  };
+}
+function touchCurrentTaskWindow(activeTaskWindows, turnId, timestamp) {
+  if (!turnId) {
+    return;
+  }
+  const activeTaskWindow = activeTaskWindows.get(turnId);
+  if (activeTaskWindow) {
+    activeTaskWindow.lastActivityAt = timestamp;
+  }
+}
+
 // src/codex-session-log/extract-user-message-timestamps.ts
 function extractUserMessageTimestamps(records) {
   const timestamps = [];
@@ -708,13 +1125,17 @@ async function parseCodexSession(sourceFilePath) {
   const tokenPoints = extractTokenPoints(records);
   const userMessageTimestamps = extractUserMessageTimestamps(records);
   const { turnAttributions, agentSpawnRequests } = extractTurnAttribution(records);
+  const sessionId = readString(sessionMetaPayload, "id", "session_meta.payload");
+  const cwd = readString(sessionMetaPayload, "cwd", "session_meta.payload");
+  const forkedFromSessionId = readOptionalString(sessionMetaPayload, "forked_from_id");
+  const kind = classifySessionKind(sessionMetaPayload.source);
   const eventTimestamps = records.filter((record) => record.type !== "session_meta").map((record) => record.timestamp);
   return {
-    sessionId: readString(sessionMetaPayload, "id", "session_meta.payload"),
+    sessionId,
     sourceFilePath,
-    cwd: readString(sessionMetaPayload, "cwd", "session_meta.payload"),
-    kind: classifySessionKind(sessionMetaPayload.source),
-    forkedFromSessionId: readOptionalString(sessionMetaPayload, "forked_from_id"),
+    cwd,
+    kind,
+    forkedFromSessionId,
     firstTimestamp: firstRecord.timestamp,
     lastTimestamp: lastRecord.timestamp,
     eventTimestamps: eventTimestamps.length > 0 ? eventTimestamps : [firstRecord.timestamp],
@@ -723,6 +1144,12 @@ async function parseCodexSession(sourceFilePath) {
     userMessageTimestamps,
     turnAttributions,
     agentSpawnRequests,
+    taskWindows: extractTaskWindows(records, {
+      cwd,
+      parentSessionId: forkedFromSessionId,
+      sessionId,
+      sessionKind: kind
+    }),
     primaryModel: resolvePrimaryModel(turnAttributions),
     primaryReasoningEffort: resolvePrimaryReasoningEffort(turnAttributions)
   };
@@ -815,26 +1242,29 @@ function buildActivityBlocks(timestamps, idleCutoffMs) {
 }
 
 // src/reporting/activity-metrics.ts
-function buildActivityMetrics(sessions, idleCutoffMs) {
+function buildActivityMetrics(sessions, idleCutoffMs, observedAt = new Date) {
   const directSessions = sessions.filter((session) => session.kind === "direct");
   const subagentSessions = sessions.filter((session) => session.kind === "subagent");
   const strictEngagementBlocks = buildActivityBlocks(directSessions.flatMap((session) => session.userMessageTimestamps), idleCutoffMs);
   const directActivityBlocks = buildActivityBlocks(directSessions.flatMap((session) => session.eventTimestamps), idleCutoffMs);
-  const perSubagentBlocks = subagentSessions.map((session) => buildActivityBlocks(session.eventTimestamps, idleCutoffMs));
-  const agentCoverageBlocks = buildActivityBlocks(subagentSessions.flatMap((session) => session.eventTimestamps), idleCutoffMs);
+  const perAgentTaskBlocks = subagentSessions.map((session) => session.taskWindows.length > 0 ? session.taskWindows.flatMap((taskWindow) => {
+    const taskWindowInterval = buildTaskWindowInterval(taskWindow, observedAt);
+    return taskWindowInterval ? [taskWindowInterval] : [];
+  }) : buildActivityBlocks(session.eventTimestamps, idleCutoffMs));
+  const agentCoverageBlocks = mergeTimeIntervals(perAgentTaskBlocks.flat());
   const agentOnlyBlocks = subtractTimeIntervals(agentCoverageBlocks, directActivityBlocks);
   return {
     strictEngagementBlocks,
     directActivityBlocks,
     agentCoverageBlocks,
     agentOnlyBlocks,
-    perSubagentBlocks,
+    perAgentTaskBlocks,
     strictEngagementMs: sumTimeIntervalsMs(strictEngagementBlocks),
     directActivityMs: sumTimeIntervalsMs(directActivityBlocks),
     agentCoverageMs: sumTimeIntervalsMs(agentCoverageBlocks),
     agentOnlyMs: sumTimeIntervalsMs(agentOnlyBlocks),
-    cumulativeAgentMs: perSubagentBlocks.reduce((totalDurationMs, sessionBlocks) => totalDurationMs + sumTimeIntervalsMs(sessionBlocks), 0),
-    peakConcurrentAgents: peakConcurrency(perSubagentBlocks)
+    cumulativeAgentMs: perAgentTaskBlocks.reduce((totalDurationMs, taskBlocks) => totalDurationMs + sumTimeIntervalsMs(taskBlocks), 0),
+    peakConcurrentAgents: peakConcurrency(perAgentTaskBlocks)
   };
 }
 
@@ -870,11 +1300,12 @@ function groupSessions(sessions, dimension) {
 // src/reporting/build-hourly-report.ts
 function buildHourlyReport(sessions, query) {
   const filteredSessions = filterSessions(sessions, query.filters);
-  const metrics = buildActivityMetrics(filteredSessions, query.idleCutoffMs);
+  const metrics = buildActivityMetrics(filteredSessions, query.idleCutoffMs, query.window.end);
   const wakeIntervals = query.wakeWindow ? buildWakeIntervalsForReportWindow(query.wakeWindow, query.window) : null;
   const buckets = buildBuckets(query.window.start, query.window.end, filteredSessions, metrics, wakeIntervals);
   return {
     appliedFilters: query.filters,
+    agentConcurrencySource: filteredSessions.some((session) => session.kind === "subagent" && session.taskWindows.length === 0) ? "task-window-adapter-with-session-fallback" : "task-window-adapter",
     buckets,
     hasWakeWindow: query.wakeWindow !== null,
     idleCutoffMs: query.idleCutoffMs,
@@ -903,7 +1334,7 @@ function buildBuckets(windowStart, windowEnd, sessions, metrics, wakeIntervals)
       awakeIdleMs,
       directActivityMs,
       engagedMs: measureOverlapMs(metrics.strictEngagementBlocks, bucketInterval),
-      peakConcurrentAgents: peakConcurrency(metrics.perSubagentBlocks.map((sessionBlocks) => clipIntervals(sessionBlocks, bucketInterval))),
+      peakConcurrentAgents: peakConcurrency(metrics.perAgentTaskBlocks.map((taskBlocks) => clipIntervals(taskBlocks, bucketInterval))),
       practicalBurn: sumTokenBurn(sessions, bucketInterval),
       rawTotalTokens: sumRawTokenDeltas(sessions, bucketInterval),
       sessionCount: countSessionsInBucket(sessions, bucketInterval)
@@ -1028,6 +1459,13 @@ function formatHourOfDay(timestamp, reportWindow) {
     hour12: false
   }).format(timestamp);
 }
+function formatAxisTimeLabel(timestamp, reportWindow) {
+  return new Intl.DateTimeFormat("en-US", {
+    timeZone: reportWindow.timeZone,
+    hour: "numeric",
+    hour12: true
+  }).format(timestamp).toLowerCase().replace(/\s+/g, "");
+}
 function buildSparkline(values) {
   const levels = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
   const maxValue = Math.max(...values, 0);
@@ -1061,18 +1499,66 @@ function shortenPath(pathText, maxLength) {
   return `...${shortenedPath || pathText.slice(-(maxLength - 3))}`;
 }
 
+// src/reporting/render-best-plaque.ts
+function buildBestPlaque(ledger) {
+  return {
+    label: "BEST",
+    concurrentAgentsText: `${formatInteger(ledger?.bestConcurrentAgents?.value ?? 0)} concurrent agents`,
+    rawBurnText: `${formatCompactInteger(ledger?.best24hRawBurn?.value ?? 0).toUpperCase()} 24hr raw burn`,
+    agentSumText: `${formatAgentSumHours(ledger?.best24hAgentSumMs?.value ?? 0)} agent sum`
+  };
+}
+function buildBestPlaqueRows(bestPlaque, availableWidth) {
+  const wideRows = [
+    bestPlaque.label,
+    bestPlaque.concurrentAgentsText,
+    bestPlaque.rawBurnText,
+    bestPlaque.agentSumText,
+    ""
+  ];
+  if (rowsFitWidth(wideRows, availableWidth)) {
+    return wideRows;
+  }
+  const compactRows = [
+    bestPlaque.label,
+    bestPlaque.concurrentAgentsText.replace(" agents", ""),
+    bestPlaque.rawBurnText.replace(" 24hr ", " "),
+    bestPlaque.agentSumText,
+    ""
+  ];
+  if (rowsFitWidth(compactRows, availableWidth)) {
+    return compactRows;
+  }
+  const microRows = [
+    bestPlaque.label,
+    compactRows[1]?.replace("concurrent", "conc") ?? "",
+    compactRows[2]?.replace(" burn", "") ?? "",
+    compactRows[3]?.replace(" agent sum", " sum") ?? "",
+    ""
+  ];
+  return rowsFitWidth(microRows, availableWidth) ? microRows : null;
+}
+function formatAgentSumHours(durationMs) {
+  const hours = durationMs / 3600000;
+  const roundedHours = hours >= 10 ? Math.round(hours).toString() : (Math.round(hours * 10) / 10).toString();
+  return roundedHours.endsWith(".0") ? roundedHours.slice(0, -2) : roundedHours;
+}
+function rowsFitWidth(rows, availableWidth) {
+  return availableWidth > 0 && rows.every((row) => row.length <= availableWidth);
+}
+
 // src/reporting/render-theme.ts
 var roleStyles = {
-  focus: "1;38;2;236;239;148",
-  active: "1;38;2;208;219;96",
-  agent: "1;38;2;166;182;77",
-  idle: "1;38;2;138;150;66",
-  burn: "1;38;2;228;209;92",
-  raw: "1;38;2;188;172;80",
-  frame: "1;38;2;149;158;56",
-  heading: "1;38;2;249;246;212",
-  muted: "38;2;142;145;96",
-  value: "1;38;2;242;236;179"
+  focus: "1;38;2;190;184;86",
+  active: "1;38;2;157;168;60",
+  agent: "1;38;2;124;138;55",
+  idle: "1;38;2;105;118;50",
+  burn: "1;38;2;190;161;55",
+  raw: "1;38;2;153;132;52",
+  frame: "1;38;2;118;126;50",
+  heading: "1;38;2;201;190;102",
+  muted: "38;2;111;115;78",
+  value: "1;38;2;178;161;68"
 };
 function createRenderOptions(shareMode) {
   return {
@@ -1110,7 +1596,9 @@ function measureVisibleTextWidth(text) {
 
 // src/reporting/render-logo-section.ts
 var baseBackgroundStyle = "48;2;12;15;8";
-var wordmarkStyle = `${baseBackgroundStyle};1;38;2;247;245;204`;
+var plaqueInsetColumns = 3;
+var plaqueTextStyle = "1;38;2;244;235;164";
+var wordmarkStyle = `${baseBackgroundStyle};1;38;2;210;198;108`;
 var wordmarkLines = [
   "       ▄▄ ▄▄",
   "▀▀     ██ ██        ██   ▀▀",
@@ -1120,59 +1608,76 @@ var wordmarkLines = [
 ];
 var patternColors = [
   { red: 20, green: 24, blue: 10 },
-  { red: 48, green: 58, blue: 18 },
-  { red: 86, green: 96, blue: 24 },
-  { red: 128, green: 138, blue: 30 },
-  { red: 176, green: 188, blue: 40 },
-  { red: 220, green: 228, blue: 78 }
+  { red: 42, green: 50, blue: 16 },
+  { red: 71, green: 81, blue: 24 },
+  { red: 101, green: 112, blue: 31 },
+  { red: 136, green: 145, blue: 39 },
+  { red: 177, green: 169, blue: 58 }
 ];
 var monochromePatternCharacters = ["░", "░", "▒", "▓", "█"];
-function buildLogoSection(requestedWidth, options) {
+function buildLogoSection(requestedWidth, options, bestPlaque = null) {
   const wordmarkWidth = Math.max(...wordmarkLines.map((line) => line.length));
   const sectionWidth = Math.max(requestedWidth, wordmarkWidth);
   const patternWidth = Math.max(0, sectionWidth - wordmarkWidth);
+  const plaqueRows = bestPlaque ? buildBestPlaqueRows(bestPlaque, Math.max(0, patternWidth - plaqueInsetColumns)) : null;
   return wordmarkLines.map((line, rowIndex) => {
     const paddedWordmark = padRight(line, wordmarkWidth);
-    const patternTail = buildPatternTail(patternWidth, rowIndex, options);
+    const patternTail = buildPatternTail(patternWidth, rowIndex, options, plaqueRows?.[rowIndex] ?? "");
     return `${paintAnsi(paddedWordmark, wordmarkStyle, options)}${patternTail}`;
   });
 }
 function resolveLogoSectionWidth(minimumWidth, options) {
   return Math.max(minimumWidth, options.terminalWidth ?? 0);
 }
-function buildPatternTail(width, rowIndex, options) {
+function buildPatternTail(width, rowIndex, options, plaqueRowText) {
   if (!options.colorEnabled) {
-    return buildMonochromePatternTail(width, rowIndex);
+    return buildMonochromePatternTail(width, rowIndex, plaqueRowText);
   }
+  const overlayCharacters = createOverlayCharacters(width, plaqueRowText);
+  const cellStyles = Array.from({ length: width }, (_, columnIndex) => getPatternCellStyle(getPatternIntensity(width, rowIndex, columnIndex)));
   let patternTail = "";
   let currentStyle = "";
-  let currentSegmentWidth = 0;
+  let currentSegment = "";
   for (let columnIndex = 0;columnIndex < width; columnIndex += 1) {
-    const style = getPatternCellStyle(getPatternIntensity(width, rowIndex, columnIndex));
+    const overlayCharacter = overlayCharacters[columnIndex];
+    const style = overlayCharacter === null ? cellStyles[columnIndex] : `${cellStyles[columnIndex]};${plaqueTextStyle}`;
     if (style === currentStyle) {
-      currentSegmentWidth += 1;
+      currentSegment += overlayCharacter ?? " ";
       continue;
     }
-    if (currentSegmentWidth > 0) {
-      patternTail += paintAnsi(" ".repeat(currentSegmentWidth), currentStyle, options);
+    if (currentSegment.length > 0) {
+      patternTail += paintAnsi(currentSegment, currentStyle, options);
     }
     currentStyle = style;
-    currentSegmentWidth = 1;
+    currentSegment = overlayCharacter ?? " ";
   }
-  if (currentSegmentWidth > 0) {
-    patternTail += paintAnsi(" ".repeat(currentSegmentWidth), currentStyle, options);
+  if (currentSegment.length > 0) {
+    patternTail += paintAnsi(currentSegment, currentStyle, options);
   }
   return patternTail;
 }
-function buildMonochromePatternTail(width, rowIndex) {
+function buildMonochromePatternTail(width, rowIndex, plaqueRowText) {
+  const overlayCharacters = createOverlayCharacters(width, plaqueRowText);
   let patternTail = "";
   for (let columnIndex = 0;columnIndex < width; columnIndex += 1) {
+    const overlayCharacter = overlayCharacters[columnIndex];
+    if (overlayCharacter !== null) {
+      patternTail += overlayCharacter;
+      continue;
+    }
     const intensity = getPatternIntensity(width, rowIndex, columnIndex);
     const characterIndex = Math.min(monochromePatternCharacters.length - 1, Math.floor(intensity * monochromePatternCharacters.length));
     patternTail += monochromePatternCharacters[characterIndex];
   }
   return patternTail;
 }
+function createOverlayCharacters(width, plaqueRowText) {
+  const overlayCharacters = Array.from({ length: width }, () => null);
+  for (let index = 0;index < plaqueRowText.length && plaqueInsetColumns + index < width; index += 1) {
+    overlayCharacters[plaqueInsetColumns + index] = plaqueRowText[index];
+  }
+  return overlayCharacters;
+}
 function getPatternIntensity(width, rowIndex, columnIndex) {
   const normalizedColumn = width <= 1 ? 0 : columnIndex / Math.max(1, width - 1);
   const envelope = 0.18 + 0.82 * Math.pow(normalizedColumn, 0.82);
@@ -1189,6 +1694,27 @@ function clamp(value, minValue, maxValue) {
   return Math.min(maxValue, Math.max(minValue, value));
 }
 
+// src/reporting/render-time-axis.ts
+var axisGroupSize = 4;
+function buildGroupedTrack(text) {
+  const groups = [];
+  for (let index = 0;index < text.length; index += axisGroupSize) {
+    groups.push(text.slice(index, index + axisGroupSize));
+  }
+  return groups.join("│");
+}
+function buildTimeAxisLine(report) {
+  const axisGroups = [];
+  for (let bucketIndex = 0;bucketIndex < report.buckets.length; bucketIndex += axisGroupSize) {
+    const bucket = report.buckets[bucketIndex];
+    if (!bucket) {
+      continue;
+    }
+    axisGroups.push(padRight(formatAxisTimeLabel(bucket.start, report.window), Math.min(axisGroupSize, report.buckets.length - bucketIndex)));
+  }
+  return axisGroups.join("│");
+}
+
 // src/reporting/render-layout.ts
 function buildPanel(title, lines) {
   const innerWidth = Math.max(56, title.length + 4, ...lines.map((line) => line.length));
@@ -1215,8 +1741,17 @@ function renderSectionTitle(title, options) {
   ];
 }
 
+// src/reporting/render-agent-section.ts
+function buildAgentSection(report, options) {
+  return [
+    ...renderSectionTitle("Agents", options),
+    paint(`  time   ${buildTimeAxisLine(report)}`, "muted", options),
+    `${paint("  conc  ", "agent", options)}${paint(buildGroupedTrack(buildSparkline(report.buckets.map((bucket) => bucket.peakConcurrentAgents))), "agent", options)}  ${paint(`${Math.max(...report.buckets.map((bucket) => bucket.peakConcurrentAgents), 0)} peak`, "value", options)}`,
+    `${paint("  unit  ", "muted", options)}${paint(report.agentConcurrencySource === "task-window-adapter" ? "task windows" : "task windows with session fallback", "muted", options)}  ${paint(padRight(formatDurationCompact(report.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + bucket.agentOnlyMs, 0)), 5), "agent", options)} ${paint("agent-only", "muted", options)}`
+  ];
+}
+
 // src/reporting/render-rhythm-section.ts
-var groupSize = 4;
 function buildRhythmSection(report, options) {
   const quietValues = report.buckets.map((bucket) => Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs));
   const idleValues = report.hasWakeWindow ? report.buckets.map((bucket) => bucket.awakeIdleMs) : quietValues;
@@ -1224,7 +1759,7 @@ function buildRhythmSection(report, options) {
   const idleTotal = formatDurationCompact(idleValues.reduce((totalDurationMs, idleDurationMs) => totalDurationMs + idleDurationMs, 0));
   const lines = [
     ...renderSectionTitle("24h Rhythm", options),
-    paint(`  hours  ${buildHourMarkerLine(report)}`, "muted", options),
+    paint(`  time   ${buildTimeAxisLine(report)}`, "muted", options),
     renderRhythmRow("focus", buildGroupedTrack(buildSparkline(report.buckets.map((bucket) => bucket.engagedMs))), formatDurationCompact(report.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + bucket.engagedMs, 0)), "focus", options),
     renderRhythmRow("active", buildGroupedTrack(buildSparkline(report.buckets.map((bucket) => bucket.directActivityMs))), formatDurationCompact(report.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + bucket.directActivityMs, 0)), "active", options)
   ];
@@ -1232,24 +1767,6 @@ function buildRhythmSection(report, options) {
   lines.push(renderRhythmRow("burn", buildGroupedTrack(buildSparkline(report.buckets.map((bucket) => bucket.practicalBurn))), formatCompactInteger(report.buckets.reduce((totalBurn, bucket) => totalBurn + bucket.practicalBurn, 0)), "burn", options));
   return lines;
 }
-function buildGroupedTrack(text) {
-  const groups = [];
-  for (let i = 0;i < text.length; i += groupSize) {
-    groups.push(text.slice(i, i + groupSize));
-  }
-  return groups.join("│");
-}
-function buildHourMarkerLine(report) {
-  const markerGroups = [];
-  for (let index = 0;index < report.buckets.length; index += groupSize) {
-    const bucket = report.buckets[index];
-    if (!bucket) {
-      continue;
-    }
-    markerGroups.push(padRight(formatHourOfDay(bucket.start, report.window), Math.min(groupSize, report.buckets.length - index)));
-  }
-  return markerGroups.join("│");
-}
 function renderRhythmRow(label, sparkline, totalText, role, options) {
   return `${paint(`  ${padRight(label, 6)}`, role, options)} ${paint(sparkline, role, options)}  ${paint(totalText, "value", options)}`;
 }
@@ -1286,6 +1803,8 @@ function renderFullHourlyReport(report, options) {
   lines.push("");
   lines.push(...panelLines);
   lines.push("");
+  lines.push(...buildAgentSection(report, options));
+  lines.push("");
   lines.push(...buildRhythmSection(report, options));
   lines.push("");
   lines.push(...buildSpikeSection(report, options));
@@ -1315,6 +1834,8 @@ function renderShareHourlyReport(report, options) {
   lines.push("");
   lines.push(...panelLines);
   lines.push("");
+  lines.push(...buildAgentSection(report, options));
+  lines.push("");
   lines.push(...buildRhythmSection(report, options));
   lines.push("");
   lines.push(...buildSpikeSection(report, options));
@@ -1341,18 +1862,111 @@ function buildFilterLine(report) {
 }
 
 // src/cli/run-hourly-command.ts
-async function runHourlyCommand(command) {
-  const window = resolveTrailingReportWindow({ durationMs: command.hourlyWindowMs });
+async function buildHourlyCommandResult(command, options = {}) {
+  const window = resolveTrailingReportWindow({
+    durationMs: command.hourlyWindowMs,
+    now: options.now
+  });
   const sessions = await readCodexSessions({
     windowStart: window.start,
-    windowEnd: window.end
+    windowEnd: window.end,
+    sessionRootDirectory: options.sessionRootDirectory
   });
-  return renderHourlyReport(buildHourlyReport(sessions, {
-    filters: command.filters,
-    idleCutoffMs: command.idleCutoffMs,
-    wakeWindow: command.wakeWindow,
-    window
-  }), createRenderOptions(command.shareMode));
+  return {
+    hourlyReport: buildHourlyReport(sessions, {
+      filters: command.filters,
+      idleCutoffMs: command.idleCutoffMs,
+      wakeWindow: command.wakeWindow,
+      window
+    })
+  };
+}
+async function runHourlyCommand(command, options = {}) {
+  const commandResult = await buildHourlyCommandResult(command, options);
+  return renderHourlyReport(commandResult.hourlyReport, createRenderOptions(command.shareMode));
+}
+
+// src/best-metrics/read-best-ledger.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/best-metrics/types.ts
+var bestMetricsLedgerVersion = 1;
+var rollingWindowDurationMs = 24 * 60 * 60 * 1000;
+var defaultBestMetricsIdleCutoffMs = 15 * 60 * 1000;
+
+// src/best-metrics/read-best-ledger.ts
+var bestLedgerFileName = "bests-v1.json";
+async function readBestLedger(options = {}) {
+  try {
+    const rawLedgerText = await readFile2(resolveBestLedgerPath(options), "utf8");
+    return parseBestLedger(JSON.parse(rawLedgerText));
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function parseBestLedger(value) {
+  const ledgerRecord = expectObject(value, "bestMetricsLedger");
+  const version = readNumber(ledgerRecord, "version", "bestMetricsLedger");
+  if (version !== bestMetricsLedgerVersion) {
+    throw new Error(`bestMetricsLedger.version must be ${bestMetricsLedgerVersion}.`);
+  }
+  return {
+    version: bestMetricsLedgerVersion,
+    initializedAt: readIsoTimestamp(ledgerRecord.initializedAt, "bestMetricsLedger.initializedAt"),
+    lastScannedAt: readIsoTimestamp(ledgerRecord.lastScannedAt, "bestMetricsLedger.lastScannedAt"),
+    bestConcurrentAgents: parseBestMetricRecord(ledgerRecord.bestConcurrentAgents, "bestMetricsLedger.bestConcurrentAgents"),
+    best24hRawBurn: parseBestMetricRecord(ledgerRecord.best24hRawBurn, "bestMetricsLedger.best24hRawBurn"),
+    best24hAgentSumMs: parseBestMetricRecord(ledgerRecord.best24hAgentSumMs, "bestMetricsLedger.best24hAgentSumMs")
+  };
+}
+function resolveBestLedgerPath(options = {}) {
+  return join2(resolveBestStateDirectory(options), bestLedgerFileName);
+}
+function serializeBestLedger(ledger) {
+  const serializedLedger = {
+    version: ledger.version,
+    initializedAt: ledger.initializedAt.toISOString(),
+    lastScannedAt: ledger.lastScannedAt.toISOString(),
+    bestConcurrentAgents: serializeBestMetricRecord(ledger.bestConcurrentAgents),
+    best24hRawBurn: serializeBestMetricRecord(ledger.best24hRawBurn),
+    best24hAgentSumMs: serializeBestMetricRecord(ledger.best24hAgentSumMs)
+  };
+  return `${JSON.stringify(serializedLedger, null, 2)}
+`;
+}
+function parseBestMetricRecord(value, label) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  const record = expectObject(value, label);
+  return {
+    value: readNumber(record, "value", label),
+    observedAt: readIsoTimestamp(record.observedAt, `${label}.observedAt`),
+    windowStart: readIsoTimestamp(record.windowStart, `${label}.windowStart`),
+    windowEnd: readIsoTimestamp(record.windowEnd, `${label}.windowEnd`)
+  };
+}
+function serializeBestMetricRecord(record) {
+  if (!record) {
+    return null;
+  }
+  return {
+    value: record.value,
+    observedAt: record.observedAt.toISOString(),
+    windowStart: record.windowStart.toISOString(),
+    windowEnd: record.windowEnd.toISOString()
+  };
+}
+function resolveBestStateDirectory(options) {
+  return options.stateDirectory ?? join2(homedir2(), ".idletime");
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/reporting/build-summary-report.ts
@@ -1362,7 +1976,7 @@ function buildSummaryReport(sessions, query) {
     start: query.window.start,
     end: query.window.end
   };
-  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(filteredSessions, query.idleCutoffMs), windowInterval);
+  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(filteredSessions, query.idleCutoffMs, query.window.end), windowInterval);
   const comparisonCutoffMs = parseDurationToMs("30m");
   const sessionCounts = {
     total: filteredSessions.length,
@@ -1373,7 +1987,7 @@ function buildSummaryReport(sessions, query) {
     activityWindow: resolveActivityWindow(filteredSessions, windowInterval),
     appliedFilters: query.filters,
     comparisonCutoffMs,
-    comparisonMetrics: query.idleCutoffMs === comparisonCutoffMs ? metrics : clipActivityMetricsToWindow(buildActivityMetrics(filteredSessions, comparisonCutoffMs), windowInterval),
+    comparisonMetrics: query.idleCutoffMs === comparisonCutoffMs ? metrics : clipActivityMetricsToWindow(buildActivityMetrics(filteredSessions, comparisonCutoffMs, query.window.end), windowInterval),
     directTokenTotals: sumTokenTotals(filteredSessions.filter((session) => session.kind === "direct"), windowInterval),
     groupBreakdowns: buildGroupBreakdowns(filteredSessions, query.groupBy, query.idleCutoffMs, windowInterval),
     idleCutoffMs: query.idleCutoffMs,
@@ -1387,11 +2001,11 @@ function buildSummaryReport(sessions, query) {
 function buildGroupBreakdowns(sessions, dimensions, idleCutoffMs, windowInterval) {
   return dimensions.map((dimension) => ({
     dimension,
-    rows: groupSessions(sessions, dimension).map((groupedSessions) => buildGroupRow(groupedSessions.key, groupedSessions.sessions, idleCutoffMs, windowInterval))
+    rows: groupSessions(sessions, dimension).map((groupedSessions) => buildGroupRow(groupedSessions.key, groupedSessions.sessions, idleCutoffMs, windowInterval, windowInterval.end))
   }));
 }
-function buildGroupRow(key, sessions, idleCutoffMs, windowInterval) {
-  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(sessions, idleCutoffMs), windowInterval);
+function buildGroupRow(key, sessions, idleCutoffMs, windowInterval, observedAt) {
+  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(sessions, idleCutoffMs, observedAt), windowInterval);
   const tokenTotals = sumTokenTotals(sessions, windowInterval);
   return {
     key,
@@ -1434,44 +2048,42 @@ function clipActivityMetricsToWindow(metrics, windowInterval) {
   const directActivityBlocks = intersectTimeIntervals(metrics.directActivityBlocks, [windowInterval]);
   const agentCoverageBlocks = intersectTimeIntervals(metrics.agentCoverageBlocks, [windowInterval]);
   const agentOnlyBlocks = intersectTimeIntervals(metrics.agentOnlyBlocks, [windowInterval]);
-  const perSubagentBlocks = metrics.perSubagentBlocks.map((sessionBlocks) => intersectTimeIntervals(sessionBlocks, [windowInterval]));
+  const perAgentTaskBlocks = metrics.perAgentTaskBlocks.map((taskBlocks) => intersectTimeIntervals(taskBlocks, [windowInterval]));
   return {
     strictEngagementBlocks,
     directActivityBlocks,
     agentCoverageBlocks,
     agentOnlyBlocks,
-    perSubagentBlocks,
+    perAgentTaskBlocks,
     strictEngagementMs: sumTimeIntervalsMs(strictEngagementBlocks),
     directActivityMs: sumTimeIntervalsMs(directActivityBlocks),
     agentCoverageMs: sumTimeIntervalsMs(agentCoverageBlocks),
     agentOnlyMs: sumTimeIntervalsMs(agentOnlyBlocks),
-    cumulativeAgentMs: perSubagentBlocks.reduce((totalDurationMs, sessionBlocks) => totalDurationMs + sumTimeIntervalsMs(sessionBlocks), 0),
-    peakConcurrentAgents: peakConcurrency(perSubagentBlocks)
+    cumulativeAgentMs: perAgentTaskBlocks.reduce((totalDurationMs, taskBlocks) => totalDurationMs + sumTimeIntervalsMs(taskBlocks), 0),
+    peakConcurrentAgents: peakConcurrency(perAgentTaskBlocks)
   };
 }
 
 // src/reporting/render-summary-report.ts
 var summaryBarWidth = 18;
-function renderSummaryReport(report, options, hourlyReport) {
-  return options.shareMode ? renderShareSummaryReport(report, options, hourlyReport) : renderFullSummaryReport(report, options, hourlyReport);
+function renderSummaryReport(report, options, hourlyReport, bestPlaque = null) {
+  return options.shareMode ? renderShareSummaryReport(report, options, hourlyReport, bestPlaque) : renderFullSummaryReport(report, options, hourlyReport, bestPlaque);
 }
-function renderFullSummaryReport(report, options, hourlyReport) {
+function renderFullSummaryReport(report, options, hourlyReport, bestPlaque = null) {
   const lines = [];
   const requestedMetrics = report.metrics;
   const actualComparisonMetrics = report.comparisonMetrics;
   const windowDurationMs = report.window.end.getTime() - report.window.start.getTime();
-  const headerLines = [
-    formatTimeRange(report.window.start, report.window.end, report.window),
-    `${report.sessionCounts.total} sessions · ${formatDurationHours(requestedMetrics.strictEngagementMs)} focused · ${formatCompactInteger(report.tokenTotals.practicalBurn)} tokens`,
-    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
-  ];
+  const headerLines = buildSummaryHeaderLines(report, hourlyReport);
   const panelLines = renderPanel(`idletime • ${report.window.label}`, headerLines, options);
   const panelWidth = measureVisibleTextWidth(panelLines[0] ?? "");
   const logoSectionWidth = resolveLogoSectionWidth(panelWidth, options);
-  lines.push(...buildLogoSection(logoSectionWidth, options));
+  lines.push(...buildLogoSection(logoSectionWidth, options, bestPlaque));
   lines.push("");
   lines.push(...panelLines);
   if (hourlyReport) {
+    lines.push("");
+    lines.push(...buildAgentSection(hourlyReport, options));
     lines.push("");
     lines.push(...buildRhythmSection(hourlyReport, options));
   }
@@ -1519,20 +2131,18 @@ function renderFullSummaryReport(report, options, hourlyReport) {
   return lines.join(`
 `);
 }
-function renderShareSummaryReport(report, options, hourlyReport) {
+function renderShareSummaryReport(report, options, hourlyReport, bestPlaque = null) {
   const lines = [];
-  const headerLines = [
-    formatTimeRange(report.window.start, report.window.end, report.window),
-    `${report.sessionCounts.total} sessions · ${formatDurationHours(report.metrics.strictEngagementMs)} focused · ${formatCompactInteger(report.tokenTotals.practicalBurn)} tokens`,
-    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
-  ];
+  const headerLines = buildSummaryHeaderLines(report, hourlyReport);
   const panelLines = renderPanel(`idletime • ${report.window.label}`, headerLines, options);
   const panelWidth = measureVisibleTextWidth(panelLines[0] ?? "");
   const logoSectionWidth = resolveLogoSectionWidth(panelWidth, options);
-  lines.push(...buildLogoSection(logoSectionWidth, options));
+  lines.push(...buildLogoSection(logoSectionWidth, options, bestPlaque));
   lines.push("");
   lines.push(...panelLines);
   if (hourlyReport) {
+    lines.push("");
+    lines.push(...buildAgentSection(hourlyReport, options));
     lines.push("");
     lines.push(...buildRhythmSection(hourlyReport, options));
   }
@@ -1563,6 +2173,93 @@ function formatAppliedFilters(report) {
   }
   return appliedFilters;
 }
+function buildSummaryHeaderLines(report, hourlyReport) {
+  if (!hourlyReport) {
+    return [
+      formatTimeRange(report.window.start, report.window.end, report.window),
+      `${report.sessionCounts.total} sessions · ${formatDurationHours(report.metrics.strictEngagementMs)} focused · ${formatCompactInteger(report.tokenTotals.practicalBurn)} tokens`,
+      ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
+    ];
+  }
+  return [
+    buildPostureLine(report, hourlyReport),
+    buildBiggestStoryLine(report, hourlyReport),
+    buildSupportFactsLine(report),
+    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
+  ];
+}
+function buildPostureLine(report, hourlyReport) {
+  const directActivityMs = Math.max(report.metrics.directActivityMs, 1);
+  const focusRatio = report.metrics.strictEngagementMs / directActivityMs;
+  const agentCoverageRatio = report.metrics.agentCoverageMs / directActivityMs;
+  const quietRatio = sumQuietMs(hourlyReport) / Math.max(1, report.window.end.getTime() - report.window.start.getTime());
+  const posture = quietRatio >= 0.45 ? "Fragmented day" : agentCoverageRatio >= 0.75 && focusRatio < 0.65 ? "Mostly orchestrating" : focusRatio >= 0.8 ? "Mostly in the loop" : report.metrics.peakConcurrentAgents >= 6 ? "Heavy agent day" : "Balanced day";
+  return `${posture}: ${formatDurationHours(report.metrics.strictEngagementMs)} focused, ${formatDurationHours(report.metrics.agentCoverageMs)} agent live`;
+}
+function buildBiggestStoryLine(report, hourlyReport) {
+  const longestQuietRun = findLongestQuietRun(hourlyReport);
+  const peakBurnBucket = hourlyReport.buckets.reduce((currentPeak, bucket) => bucket.practicalBurn > currentPeak.practicalBurn ? bucket : currentPeak, hourlyReport.buckets[0]);
+  const quietPhrase = longestQuietRun.durationMs >= 2 * 3600000 ? `long quiet stretch ${describeDayPeriod(longestQuietRun.start, report)}` : "steady rhythm overall";
+  return `Biggest story: ${quietPhrase}, big burn ${describeDayPeriod(peakBurnBucket.start, report)}`;
+}
+function buildSupportFactsLine(report) {
+  return `${report.sessionCounts.direct} direct / ${report.sessionCounts.subagent} subagent • ${report.metrics.peakConcurrentAgents} peak • ${formatCompactInteger(report.tokenTotals.practicalBurn)} burn`;
+}
+function sumQuietMs(hourlyReport) {
+  return hourlyReport.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs), 0);
+}
+function findLongestQuietRun(hourlyReport) {
+  let longestQuietRun = {
+    durationMs: 0,
+    start: hourlyReport.buckets[0]?.start ?? new Date(0)
+  };
+  let currentStart = null;
+  let currentDurationMs = 0;
+  for (const bucket of hourlyReport.buckets) {
+    const quietMs = Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs);
+    const isQuietBucket = quietMs >= 30 * 60000;
+    if (isQuietBucket) {
+      currentStart ??= bucket.start;
+      currentDurationMs += quietMs;
+      continue;
+    }
+    if (currentStart && currentDurationMs > longestQuietRun.durationMs) {
+      longestQuietRun = {
+        durationMs: currentDurationMs,
+        start: currentStart
+      };
+    }
+    currentStart = null;
+    currentDurationMs = 0;
+  }
+  if (currentStart && currentDurationMs > longestQuietRun.durationMs) {
+    longestQuietRun = {
+      durationMs: currentDurationMs,
+      start: currentStart
+    };
+  }
+  if (longestQuietRun.durationMs > 0) {
+    return longestQuietRun;
+  }
+  const quietestBucket = hourlyReport.buckets.reduce((currentQuietest, bucket) => {
+    const quietMs = Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs);
+    return quietMs > currentQuietest.durationMs ? { durationMs: quietMs, start: bucket.start } : currentQuietest;
+  }, longestQuietRun);
+  return quietestBucket;
+}
+function describeDayPeriod(timestamp, report) {
+  const hourOfDay = Number.parseInt(formatHourOfDay(timestamp, report.window), 10);
+  if (hourOfDay >= 21 || hourOfDay < 5) {
+    return "overnight";
+  }
+  if (hourOfDay < 12) {
+    return "this morning";
+  }
+  if (hourOfDay < 17) {
+    return "this afternoon";
+  }
+  return "this evening";
+}
 function formatDurationLabel(durationMs) {
   return `${Math.round(durationMs / 60000)}m`;
 }
@@ -1574,12 +2271,21 @@ function renderSnapshotRow(label, primaryText, detailText, role, options) {
 }
 
 // src/cli/run-last24h-command.ts
-async function runLast24hCommand(command) {
-  const window = resolveTrailingReportWindow({ durationMs: command.hourlyWindowMs });
-  const sessions = await readCodexSessions({
+async function buildLast24hCommandResult(command, options = {}) {
+  const window = resolveTrailingReportWindow({
+    durationMs: command.hourlyWindowMs,
+    now: options.now
+  });
+  const bestLedgerPromise = readBestLedger({ stateDirectory: options.stateDirectory });
+  const sessionsPromise = readCodexSessions({
     windowStart: window.start,
-    windowEnd: window.end
+    windowEnd: window.end,
+    sessionRootDirectory: options.sessionRootDirectory
   });
+  const [bestLedger, sessions] = await Promise.all([
+    bestLedgerPromise,
+    sessionsPromise
+  ]);
   const summaryReport = buildSummaryReport(sessions, {
     filters: command.filters,
     groupBy: command.groupBy,
@@ -1593,39 +2299,1066 @@ async function runLast24hCommand(command) {
     wakeWindow: command.wakeWindow,
     window
   });
-  return renderSummaryReport(summaryReport, createRenderOptions(command.shareMode), hourlyReport);
+  return {
+    bestLedger,
+    hourlyReport,
+    summaryReport
+  };
 }
-
-// src/cli/run-today-command.ts
-async function runTodayCommand(command) {
-  const window = resolveTodayReportWindow();
-  const sessions = await readCodexSessions({
-    windowStart: window.start,
-    windowEnd: window.end
-  });
-  return renderSummaryReport(buildSummaryReport(sessions, {
-    filters: command.filters,
-    groupBy: command.groupBy,
-    idleCutoffMs: command.idleCutoffMs,
-    wakeWindow: command.wakeWindow,
-    window
-  }), createRenderOptions(command.shareMode));
+async function runLast24hCommand(command, options = {}) {
+  const commandResult = await buildLast24hCommandResult(command, options);
+  return renderSummaryReport(commandResult.summaryReport, createRenderOptions(command.shareMode), commandResult.hourlyReport, commandResult.bestLedger ? buildBestPlaque(commandResult.bestLedger) : null);
 }
 
-// src/cli/run-idletime.ts
-async function runIdletimeCli(argv) {
-  const command = parseIdletimeCommand(argv);
-  if (command.helpRequested) {
-    console.log(renderHelpText());
-    return;
+// src/reporting/build-live-report.ts
+var doneRecentWindowMs = 15 * 60000;
+var directSessionWarmMs = 15 * 60000;
+var recentConcurrencyBucketCount = 15;
+var recentConcurrencyBucketMs = 60000;
+var waitingOnUserWarmMs = 30 * 60000;
+function buildLiveReport(sessions, query) {
+  const observedAt = query.observedAt ?? new Date;
+  const appliedFilters = { ...query.filters };
+  const filteredSessions = filterSessions(sessions, appliedFilters);
+  const liveTaskWindows = filteredSessions.flatMap((session) => session.taskWindows);
+  const runningTaskWindows = liveTaskWindows.filter((taskWindow) => isTaskWindowRunning(taskWindow, observedAt));
+  const waitingOnUserThreads = resolveWaitingOnUserThreads(filteredSessions, observedAt);
+  const childTaskWindows = filteredSessions.filter((session) => session.kind === "subagent").flatMap((session) => session.taskWindows);
+  const recentWindowStart = new Date(observedAt.getTime() - doneRecentWindowMs);
+  return {
+    appliedFilters,
+    doneRecentCount: liveTaskWindows.filter((taskWindow) => isTaskWindowCompletedBetween(taskWindow, recentWindowStart, observedAt)).length,
+    doneRecentWindowMs,
+    doneThisTurnCount: countDoneThisTurn(filteredSessions, childTaskWindows, observedAt),
+    observedAt,
+    peakTodayCount: peakConcurrency([
+      collectTaskIntervalsForWindow(liveTaskWindows, observedAt, startOfLocalDay2(observedAt), observedAt)
+    ]),
+    recentConcurrencyValues: buildRecentConcurrencyValues(liveTaskWindows, observedAt),
+    runningCount: runningTaskWindows.length,
+    runningLocations: buildRunningLocations(runningTaskWindows),
+    waitingThreads: waitingOnUserThreads,
+    waitingOnUserCount: waitingOnUserThreads.length,
+    waitingOnUserLocations: buildWaitingOnUserLocations(waitingOnUserThreads),
+    scope: appliedFilters.workspaceOnlyPrefix ? "workspace" : "global",
+    workspacePrefix: appliedFilters.workspaceOnlyPrefix
+  };
+}
+function buildRunningLocations(runningTaskWindows) {
+  const runningLocations = new Map;
+  for (const taskWindow of runningTaskWindows) {
+    runningLocations.set(taskWindow.cwd, (runningLocations.get(taskWindow.cwd) ?? 0) + 1);
   }
-  if (command.versionRequested) {
-    console.log(package_default.version);
-    return;
+  return [...runningLocations.entries()].map(([cwd, runningCount]) => ({ cwd, runningCount })).sort((leftLocation, rightLocation) => rightLocation.runningCount - leftLocation.runningCount || leftLocation.cwd.localeCompare(rightLocation.cwd));
+}
+function buildWaitingOnUserLocations(waitingOnUserThreads) {
+  const waitingLocations = new Map;
+  for (const waitingThread of waitingOnUserThreads) {
+    waitingLocations.set(waitingThread.cwd, (waitingLocations.get(waitingThread.cwd) ?? 0) + 1);
   }
-  const output = command.commandName === "hourly" ? await runHourlyCommand(command) : command.commandName === "today" ? await runTodayCommand(command) : await runLast24hCommand(command);
+  return [...waitingLocations.entries()].map(([cwd, waitingCount]) => ({ cwd, waitingCount })).sort((leftLocation, rightLocation) => rightLocation.waitingCount - leftLocation.waitingCount || leftLocation.cwd.localeCompare(rightLocation.cwd));
+}
+function buildRecentConcurrencyValues(taskWindows, observedAt) {
+  const values = [];
+  for (let bucketIndex = recentConcurrencyBucketCount - 1;bucketIndex >= 0; bucketIndex -= 1) {
+    const bucketStart = new Date(observedAt.getTime() - (bucketIndex + 1) * recentConcurrencyBucketMs);
+    const bucketEnd = new Date(bucketStart.getTime() + recentConcurrencyBucketMs);
+    values.push(peakConcurrency([
+      collectTaskIntervalsForWindow(taskWindows, observedAt, bucketStart, bucketEnd)
+    ]));
+  }
+  return values;
+}
+function collectTaskIntervalsForWindow(taskWindows, observedAt, windowStart, windowEnd) {
+  return taskWindows.flatMap((taskWindow) => {
+    const taskWindowInterval = buildTaskWindowInterval(taskWindow, observedAt);
+    if (!taskWindowInterval) {
+      return [];
+    }
+    const clippedStart = new Date(Math.max(taskWindowInterval.start.getTime(), windowStart.getTime()));
+    const clippedEnd = new Date(Math.min(taskWindowInterval.end.getTime(), windowEnd.getTime()));
+    if (clippedStart.getTime() >= clippedEnd.getTime()) {
+      return [];
+    }
+    return [{ start: clippedStart, end: clippedEnd }];
+  });
+}
+function countDoneThisTurn(sessions, subagentTaskWindows, observedAt) {
+  const rootTurnAnchor = resolveRootTurnAnchor(sessions, observedAt);
+  if (!rootTurnAnchor) {
+    return 0;
+  }
+  return subagentTaskWindows.filter((taskWindow) => {
+    if (taskWindow.parentSessionId !== rootTurnAnchor.sessionId || !taskWindow.completedAt) {
+      return false;
+    }
+    return taskWindow.completedAt.getTime() > rootTurnAnchor.startedAt.getTime() && taskWindow.completedAt.getTime() <= observedAt.getTime();
+  }).length;
+}
+function resolveRootTurnAnchor(sessions, observedAt) {
+  const warmCutoff = observedAt.getTime() - directSessionWarmMs;
+  const warmDirectSessions = sessions.filter((session) => session.kind === "direct").filter((session) => session.lastTimestamp.getTime() >= warmCutoff).filter((session) => session.userMessageTimestamps.length > 0);
+  if (warmDirectSessions.length === 0) {
+    return null;
+  }
+  const activeRootSession = warmDirectSessions.reduce((latestSession, session) => session.lastTimestamp.getTime() > latestSession.lastTimestamp.getTime() ? session : latestSession);
+  const latestUserMessageTimestamp = activeRootSession.userMessageTimestamps[activeRootSession.userMessageTimestamps.length - 1] ?? null;
+  if (!latestUserMessageTimestamp) {
+    return null;
+  }
+  return {
+    sessionId: activeRootSession.sessionId,
+    startedAt: latestUserMessageTimestamp
+  };
+}
+function resolveWaitingOnUserThreads(sessions, observedAt) {
+  const warmCutoff = observedAt.getTime() - waitingOnUserWarmMs;
+  return sessions.flatMap((session) => {
+    if (session.kind !== "direct" || session.taskWindows.length === 0) {
+      return [];
+    }
+    const latestTaskWindow = session.taskWindows.reduce((latestWindow, taskWindow) => taskWindow.startedAt.getTime() > latestWindow.startedAt.getTime() ? taskWindow : latestWindow);
+    const latestUserMessageTimestamp = session.userMessageTimestamps[session.userMessageTimestamps.length - 1] ?? null;
+    if (latestTaskWindow.completedAt === null || !latestUserMessageTimestamp || latestTaskWindow.completedAt.getTime() <= latestUserMessageTimestamp.getTime()) {
+      return [];
+    }
+    if (latestTaskWindow.completedAt.getTime() < warmCutoff) {
+      return [];
+    }
+    return [
+      {
+        cwd: session.cwd,
+        sessionId: session.sessionId,
+        waitDurationMs: observedAt.getTime() - latestTaskWindow.completedAt.getTime(),
+        waitingSince: latestTaskWindow.completedAt
+      }
+    ];
+  }).sort((leftThread, rightThread) => rightThread.waitDurationMs - leftThread.waitDurationMs || leftThread.waitingSince.getTime() - rightThread.waitingSince.getTime());
+}
+function startOfLocalDay2(timestamp) {
+  return new Date(timestamp.getFullYear(), timestamp.getMonth(), timestamp.getDate(), 0, 0, 0, 0);
+}
+
+// src/reporting/render-live-report.ts
+import { basename } from "node:path";
+var bigDigitGlyphs = {
+  "0": ["█▀█", "█ █", "▀▀▀"],
+  "1": [" ▄█", "  █", "▄▄█"],
+  "2": ["█▀█", " ▄▀", "█▄▄"],
+  "3": ["█▀█", " ▀▄", "█▄█"],
+  "4": ["█ █", "█▄█", "  █"],
+  "5": ["█▀▀", "▀▀▄", "▄▄█"],
+  "6": ["█▀▀", "█▀█", "█▄█"],
+  "7": ["█▀█", "  █", "  █"],
+  "8": ["█▀█", "█▄█", "█▄█"],
+  "9": ["█▀█", "█▄█", "  █"]
+};
+function renderLiveReport(report, options) {
+  const headerLines = renderPanel("idletime live", [
+    buildScopeLine(report),
+    `observed ${formatTimestamp(report.observedAt, { timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone })} • refresh 5s`,
+    buildContextLine(report)
+  ], options);
+  const panelWidth = measureVisibleTextWidth(headerLines[0] ?? "");
+  const lines = [];
+  lines.push(...buildLogoSection(panelWidth, options));
+  lines.push("");
+  lines.push(...headerLines);
+  lines.push("");
+  lines.push(...buildScoreboardSection(report, options));
+  return lines.join(`
+`);
+}
+function renderLiveErrorReport(workspacePrefix, error, options) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const panelLines = renderPanel("idletime live", [
+    workspacePrefix ? `scope workspace • ${shortenPath(workspacePrefix, 40)}` : "scope global",
+    "live refresh failed; retrying in 5s",
+    errorMessage
+  ], options);
+  const panelWidth = measureVisibleTextWidth(panelLines[0] ?? "");
+  return [...buildLogoSection(panelWidth, options), "", ...panelLines].join(`
+`);
+}
+function buildScopeLine(report) {
+  return report.scope === "workspace" && report.workspacePrefix ? `scope workspace • ${shortenPath(report.workspacePrefix, 40)}` : "scope global";
+}
+function buildContextLine(report) {
+  const filterParts = [];
+  if (report.appliedFilters.model) {
+    filterParts.push(`model ${report.appliedFilters.model}`);
+  }
+  if (report.appliedFilters.reasoningEffort) {
+    filterParts.push(`effort ${report.appliedFilters.reasoningEffort}`);
+  }
+  if (report.appliedFilters.sessionKind) {
+    filterParts.push(`kind ${report.appliedFilters.sessionKind}`);
+  }
+  return filterParts.length > 0 ? filterParts.join(" • ") : "all sessions";
+}
+function renderBigDigits(value) {
+  const rows = ["", "", ""];
+  for (const character of value) {
+    const glyph = bigDigitGlyphs[character] ?? ["   ", " ? ", "   "];
+    rows[0] += `${glyph[0]} `;
+    rows[1] += `${glyph[1]} `;
+    rows[2] += `${glyph[2]} `;
+  }
+  return rows;
+}
+function buildScoreboardSection(report, options) {
+  const waitingLabel = "waiting on you";
+  const runningLabel = "running";
+  const waitingDigits = renderBigDigits(report.waitingOnUserCount.toString());
+  const runningDigits = renderBigDigits(report.runningCount.toString());
+  const leftColumnWidth = Math.max(waitingLabel.length, ...waitingDigits.map((line) => line.length));
+  const rightColumnWidth = Math.max(runningLabel.length, ...runningDigits.map((line) => line.length));
+  const columnGap = "    ";
+  const lines = [
+    joinScoreboardColumns(waitingLabel, runningLabel, leftColumnWidth, rightColumnWidth, options),
+    ...waitingDigits.map((line, lineIndex) => joinScoreboardColumns(line, runningDigits[lineIndex] ?? "", leftColumnWidth, rightColumnWidth, options)),
+    "",
+    `${paint("  recent     ", "muted", options)}${paint(buildSparkline(report.recentConcurrencyValues), "agent", options)}`,
+    ...buildRunningLocationLines(report, options),
+    ...buildWaitingLocationLines(report, options),
+    ...buildWaitingThreadLines(report, options),
+    `${paint("  this turn  ", "muted", options)}${paint(`${report.doneThisTurnCount} done`, "value", options)}`,
+    `${paint("  today peak ", "muted", options)}${paint(`${report.peakTodayCount} concurrent`, "value", options)}`
+  ];
+  function joinScoreboardColumns(leftValue, rightValue, leftWidth, rightWidth, renderOptions) {
+    return `  ${paint(padRight(leftValue, leftWidth), "agent", renderOptions)}${columnGap}${paint(padRight(rightValue, rightWidth), "value", renderOptions)}`;
+  }
+  return lines;
+}
+function buildRunningLocationLines(report, options) {
+  if (report.runningLocations.length === 0) {
+    return [
+      `${paint("  running at ", "muted", options)}${paint("no active tasks", "muted", options)}`
+    ];
+  }
+  const visibleLocations = report.runningLocations.slice(0, 3);
+  const lines = visibleLocations.map((location, locationIndex) => {
+    const label = locationIndex === 0 ? "  running at " : "             ";
+    return `${paint(label, "muted", options)}${paint(`${location.runningCount} ${formatLocationLabel(location.cwd)}`, "value", options)}`;
+  });
+  const hiddenLocationCount = report.runningLocations.length - visibleLocations.length;
+  if (hiddenLocationCount > 0) {
+    lines.push(`${paint("             ", "muted", options)}${paint(`+${hiddenLocationCount} more`, "muted", options)}`);
+  }
+  return lines;
+}
+function buildWaitingLocationLines(report, options) {
+  if (report.waitingOnUserLocations.length === 0) {
+    return [
+      `${paint("  waiting at ", "muted", options)}${paint("nothing waiting", "muted", options)}`
+    ];
+  }
+  const visibleLocations = report.waitingOnUserLocations.slice(0, 3);
+  const lines = visibleLocations.map((location, locationIndex) => {
+    const label = locationIndex === 0 ? "  waiting at " : "             ";
+    return `${paint(label, "muted", options)}${paint(`${location.waitingCount} ${formatLocationLabel(location.cwd)}`, "value", options)}`;
+  });
+  const hiddenLocationCount = report.waitingOnUserLocations.length - visibleLocations.length;
+  if (hiddenLocationCount > 0) {
+    lines.push(`${paint("             ", "muted", options)}${paint(`+${hiddenLocationCount} more`, "muted", options)}`);
+  }
+  return lines;
+}
+function buildWaitingThreadLines(report, options) {
+  if (report.waitingThreads.length === 0) {
+    return [];
+  }
+  return report.waitingThreads.slice(0, 3).map((waitingThread, waitingIndex) => {
+    const label = waitingIndex === 0 ? "  top waiting " : "              ";
+    return `${paint(label, "muted", options)}${paint(`${formatLocationLabel(waitingThread.cwd)} • ${formatDurationCompact(waitingThread.waitDurationMs)} • ${formatThreadLabel(waitingThread.sessionId)}`, "value", options)}`;
+  });
+}
+function formatLocationLabel(cwd) {
+  if (cwd.endsWith("/.agents")) {
+    return "~/.agents";
+  }
+  return basename(cwd) || shortenPath(cwd, 24);
+}
+function formatThreadLabel(sessionId) {
+  return sessionId.slice(-6);
+}
+
+// src/cli/run-live-command.ts
+var liveRefreshIntervalMs = 5000;
+var enterLiveScreenSequence = "\x1B[?1049h\x1B[2J\x1B[H\x1B[?25l";
+var exitLiveScreenSequence = "\x1B[0m\x1B[?25h\x1B[?1049l";
+async function runLiveCommand(command) {
+  const renderOptions = createRenderOptions(false);
+  if (!process.stdout.isTTY) {
+    const liveReport = await takeLiveSnapshot(command);
+    console.log(renderLiveReport(liveReport, renderOptions));
+    return;
+  }
+  let shouldStop = false;
+  let previousFrameLineCount = 0;
+  const canCaptureInput = process.stdin.isTTY && typeof process.stdin.setRawMode === "function";
+  const stopLiveLoop = () => {
+    shouldStop = true;
+  };
+  const handleInput = (input) => {
+    const inputText = typeof input === "string" ? input : input.toString("utf8");
+    if (inputText.includes("\x03") || inputText.toLowerCase().includes("q")) {
+      stopLiveLoop();
+    }
+  };
+  process.on("SIGINT", stopLiveLoop);
+  process.on("SIGTERM", stopLiveLoop);
+  if (canCaptureInput) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", handleInput);
+  }
+  process.stdout.write(enterLiveScreenSequence);
+  try {
+    while (!shouldStop) {
+      const observedAt = new Date;
+      try {
+        const liveReport = await takeLiveSnapshot(command, {
+          observedAt
+        });
+        previousFrameLineCount = drawFrame(renderLiveReport(liveReport, renderOptions), previousFrameLineCount);
+      } catch (error) {
+        previousFrameLineCount = drawFrame(renderLiveErrorReport(command.filters.workspaceOnlyPrefix, error, renderOptions), previousFrameLineCount);
+      }
+      if (shouldStop) {
+        break;
+      }
+      await waitForNextRefresh();
+    }
+  } finally {
+    process.off("SIGINT", stopLiveLoop);
+    process.off("SIGTERM", stopLiveLoop);
+    if (canCaptureInput) {
+      process.stdin.off("data", handleInput);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    process.stdout.write(exitLiveScreenSequence);
+  }
+}
+async function takeLiveSnapshot(command, options = {}) {
+  const observedAt = options.observedAt ?? new Date;
+  const recentWindow = resolveTrailingReportWindow({
+    durationMs: 24 * 60 * 60 * 1000,
+    now: observedAt
+  });
+  const sessions = await readCodexSessions({
+    windowStart: recentWindow.start,
+    windowEnd: observedAt,
+    sessionRootDirectory: options.sessionRootDirectory
+  });
+  return buildLiveReport(sessions, {
+    filters: command.filters,
+    observedAt
+  });
+}
+function drawFrame(frameText, previousFrameLineCount) {
+  const frameLines = frameText.split(`
+`);
+  process.stdout.write("\x1B[H");
+  for (const [lineIndex, line] of frameLines.entries()) {
+    if (lineIndex > 0) {
+      process.stdout.write(`
+\r`);
+    }
+    process.stdout.write("\x1B[2K");
+    process.stdout.write(line);
+  }
+  for (let lineIndex = frameLines.length;lineIndex < previousFrameLineCount; lineIndex += 1) {
+    process.stdout.write(`
+\r\x1B[2K`);
+  }
+  return frameLines.length;
+}
+function waitForNextRefresh() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, liveRefreshIntervalMs);
+  });
+}
+
+// src/best-metrics/notification-delivery.ts
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function deliverLocalNotifications(notifications, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "darwin" || notifications.length === 0) {
+    return;
+  }
+  const notifier = options.notifier ?? sendMacOsNotification;
+  for (const notification of notifications) {
+    try {
+      await notifier(notification);
+    } catch {
+      return;
+    }
+  }
+}
+async function sendMacOsNotification(notification) {
+  const notificationIconPath = resolveNotificationIconPath();
+  try {
+    await execFileAsync("terminal-notifier", [
+      "-title",
+      notification.title,
+      "-message",
+      notification.body,
+      ...notificationIconPath ? ["-appIcon", pathToFileURL(notificationIconPath).href] : []
+    ]);
+    return;
+  } catch (error) {
+    if (!isCommandMissingError(error)) {
+      throw error;
+    }
+  }
+  await execFileAsync("osascript", [
+    "-e",
+    `display notification "${escapeAppleScriptText(notification.body)}" with title "${escapeAppleScriptText(notification.title)}"`
+  ]);
+}
+function escapeAppleScriptText(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+}
+function resolveNotificationIconPath() {
+  const candidatePaths = [
+    fileURLToPath(new URL("../../assets/idle-time-notification-icon.png", import.meta.url)),
+    fileURLToPath(new URL("../assets/idle-time-notification-icon.png", import.meta.url))
+  ];
+  return candidatePaths.find((candidatePath) => existsSync(candidatePath)) ?? null;
+}
+function isCommandMissingError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/best-metrics/near-best-notifications.ts
+import { mkdir, readFile as readFile3, rename, writeFile } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+var nearBestNotificationStateFileName = "near-best-notifications-v1.json";
+var nearBestNotificationVersion = 1;
+async function notifyNearBestMetrics(currentMetrics, ledger, options = {}) {
+  const now = options.now ?? new Date;
+  const state = await ensureNearBestNotificationState(options);
+  if (!state.nearBestEnabled) {
+    return [];
+  }
+  const metricsToNotify = buildNearBestMetricKeys(currentMetrics, ledger, state, now);
+  if (metricsToNotify.length === 0) {
+    return [];
+  }
+  const nextState = {
+    ...state,
+    lastNotifiedAt: {
+      ...state.lastNotifiedAt,
+      ...Object.fromEntries(metricsToNotify.map((metric) => [metric, now]))
+    }
+  };
+  await writeNearBestNotificationState(nextState, options);
+  await deliverLocalNotifications(metricsToNotify.map((metric) => buildNearBestNotification(metric, currentMetrics[metric], ledger[metric]?.value ?? 0)), options);
+  return metricsToNotify;
+}
+async function ensureNearBestNotificationState(options) {
+  const existingState = await readNearBestNotificationState(options);
+  if (existingState) {
+    return existingState;
+  }
+  const defaultState = createDefaultNearBestNotificationState();
+  await writeNearBestNotificationState(defaultState, options);
+  return defaultState;
+}
+async function readNearBestNotificationState(options) {
+  try {
+    const rawStateText = await readFile3(resolveNearBestNotificationStatePath(options), "utf8");
+    return parseNearBestNotificationState(JSON.parse(rawStateText));
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function parseNearBestNotificationState(value) {
+  const stateRecord = expectObject(value, "nearBestNotificationState");
+  const version = readNumber(stateRecord, "version", "nearBestNotificationState");
+  if (version !== nearBestNotificationVersion) {
+    throw new Error(`nearBestNotificationState.version must be ${nearBestNotificationVersion}.`);
+  }
+  const lastNotifiedAtRecord = expectObject(stateRecord.lastNotifiedAt, "nearBestNotificationState.lastNotifiedAt");
+  return {
+    version,
+    nearBestEnabled: Boolean(stateRecord.nearBestEnabled),
+    thresholdRatio: readNumber(stateRecord, "thresholdRatio", "nearBestNotificationState"),
+    cooldownMs: readNumber(stateRecord, "cooldownMs", "nearBestNotificationState"),
+    lastNotifiedAt: {
+      bestConcurrentAgents: readOptionalIsoTimestamp(lastNotifiedAtRecord.bestConcurrentAgents, "nearBestNotificationState.lastNotifiedAt.bestConcurrentAgents"),
+      best24hRawBurn: readOptionalIsoTimestamp(lastNotifiedAtRecord.best24hRawBurn, "nearBestNotificationState.lastNotifiedAt.best24hRawBurn"),
+      best24hAgentSumMs: readOptionalIsoTimestamp(lastNotifiedAtRecord.best24hAgentSumMs, "nearBestNotificationState.lastNotifiedAt.best24hAgentSumMs")
+    }
+  };
+}
+async function writeNearBestNotificationState(state, options) {
+  const statePath = resolveNearBestNotificationStatePath(options);
+  const stateDirectory = options.stateDirectory ?? join3(homedir3(), ".idletime");
+  await mkdir(stateDirectory, { recursive: true });
+  const temporaryPath = join3(stateDirectory, `.near-best-notifications.${process.pid}.${Date.now()}.tmp`);
+  await writeFile(temporaryPath, `${JSON.stringify({
+    version: state.version,
+    nearBestEnabled: state.nearBestEnabled,
+    thresholdRatio: state.thresholdRatio,
+    cooldownMs: state.cooldownMs,
+    lastNotifiedAt: {
+      bestConcurrentAgents: state.lastNotifiedAt.bestConcurrentAgents?.toISOString() ?? null,
+      best24hRawBurn: state.lastNotifiedAt.best24hRawBurn?.toISOString() ?? null,
+      best24hAgentSumMs: state.lastNotifiedAt.best24hAgentSumMs?.toISOString() ?? null
+    }
+  }, null, 2)}
+`, "utf8");
+  await rename(temporaryPath, statePath);
+}
+function buildNearBestMetricKeys(currentMetrics, ledger, state, now) {
+  return [
+    "bestConcurrentAgents",
+    "best24hRawBurn",
+    "best24hAgentSumMs"
+  ].filter((metric) => {
+    const bestValue = ledger[metric]?.value ?? 0;
+    if (bestValue <= 0) {
+      return false;
+    }
+    const currentValue = currentMetrics[metric];
+    if (currentValue <= 0 || currentValue >= bestValue) {
+      return false;
+    }
+    if (currentValue / bestValue < state.thresholdRatio) {
+      return false;
+    }
+    const lastNotifiedAt = state.lastNotifiedAt[metric];
+    return lastNotifiedAt === null || now.getTime() - lastNotifiedAt.getTime() >= state.cooldownMs;
+  });
+}
+function buildNearBestNotification(metric, currentValue, bestValue) {
+  return {
+    title: metric === "bestConcurrentAgents" ? "Close to best concurrent agents" : metric === "best24hRawBurn" ? "Close to best 24hr raw burn" : "Close to best agent sum",
+    body: metric === "bestConcurrentAgents" ? `${formatInteger2(currentValue)} of ${formatInteger2(bestValue)} concurrent agents` : metric === "best24hRawBurn" ? `${formatCompactInteger2(currentValue)} of ${formatCompactInteger2(bestValue)} 24hr raw burn` : `${formatAgentSumHours2(currentValue)} of ${formatAgentSumHours2(bestValue)} agent sum`
+  };
+}
+function createDefaultNearBestNotificationState() {
+  return {
+    version: nearBestNotificationVersion,
+    nearBestEnabled: false,
+    thresholdRatio: 0.97,
+    cooldownMs: 24 * 60 * 60 * 1000,
+    lastNotifiedAt: {
+      bestConcurrentAgents: null,
+      best24hRawBurn: null,
+      best24hAgentSumMs: null
+    }
+  };
+}
+function resolveNearBestNotificationStatePath(options) {
+  return join3(options.stateDirectory ?? join3(homedir3(), ".idletime"), nearBestNotificationStateFileName);
+}
+function readOptionalIsoTimestamp(value, label) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  return readIsoTimestamp(value, label);
+}
+function formatAgentSumHours2(durationMs) {
+  const hours = durationMs / 3600000;
+  return hours >= 10 ? Math.round(hours).toString() : (Math.round(hours * 10) / 10).toString();
+}
+function formatCompactInteger2(value) {
+  return new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumFractionDigits: 1
+  }).format(Math.round(value)).toUpperCase();
+}
+function formatInteger2(value) {
+  return new Intl.NumberFormat("en-US").format(Math.round(value));
+}
+
+// src/best-metrics/notify-best-events.ts
+async function notifyBestEvents(bestEvents, options = {}) {
+  await deliverLocalNotifications(bestEvents.map((bestEvent) => buildBestEventNotification(bestEvent)), options);
+}
+function buildBestEventNotification(bestEvent) {
+  return {
+    title: resolveNotificationTitle(bestEvent.metric),
+    body: resolveNotificationBody(bestEvent)
+  };
+}
+function resolveNotificationTitle(bestMetricKey) {
+  return bestMetricKey === "bestConcurrentAgents" ? "New best concurrent agents" : bestMetricKey === "best24hRawBurn" ? "New best 24hr raw burn" : "New best agent sum";
+}
+function resolveNotificationBody(bestEvent) {
+  return bestEvent.metric === "bestConcurrentAgents" ? `${formatInteger3(bestEvent.value)} concurrent agents` : bestEvent.metric === "best24hRawBurn" ? `${formatCompactInteger3(bestEvent.value)} 24hr raw burn` : `${formatAgentSumHours3(bestEvent.value)} agent sum`;
+}
+function formatAgentSumHours3(durationMs) {
+  const hours = durationMs / 3600000;
+  return hours >= 10 ? Math.round(hours).toString() : (Math.round(hours * 10) / 10).toString();
+}
+function formatCompactInteger3(value) {
+  return new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumFractionDigits: 1
+  }).format(Math.round(value)).toUpperCase();
+}
+function formatInteger3(value) {
+  return new Intl.NumberFormat("en-US").format(Math.round(value));
+}
+
+// src/best-metrics/build-current-best-metrics.ts
+function buildCurrentBestMetricValues(sessions, options = {}) {
+  const idleCutoffMs = options.idleCutoffMs ?? defaultBestMetricsIdleCutoffMs;
+  const now = options.now ?? new Date;
+  const activityMetrics = buildActivityMetrics(sessions, idleCutoffMs, now);
+  const currentWindow = {
+    start: new Date(now.getTime() - rollingWindowDurationMs),
+    end: now
+  };
+  return {
+    bestConcurrentAgents: countLiveSubagents(activityMetrics.perAgentTaskBlocks, now),
+    best24hRawBurn: sessions.reduce((rawBurnTotal, session) => rawBurnTotal + buildTokenDeltaPoints(session.tokenPoints).filter((tokenDeltaPoint) => tokenDeltaPoint.timestamp.getTime() >= currentWindow.start.getTime() && tokenDeltaPoint.timestamp.getTime() <= currentWindow.end.getTime()).reduce((sessionTotal, tokenDeltaPoint) => sessionTotal + tokenDeltaPoint.deltaUsage.totalTokens, 0), 0),
+    best24hAgentSumMs: measureOverlapMs(activityMetrics.perAgentTaskBlocks.flatMap((taskBlocks) => taskBlocks), currentWindow)
+  };
+}
+function countLiveSubagents(intervalGroups, now) {
+  return intervalGroups.reduce((liveCount, intervalGroup) => liveCount + Number(intervalGroup.some((interval) => interval.start.getTime() <= now.getTime() && interval.end.getTime() > now.getTime())), 0);
+}
+
+// src/best-metrics/append-best-events.ts
+import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+var bestEventsFileName = "best-events.ndjson";
+async function appendBestEvents(bestEvents, options = {}) {
+  if (bestEvents.length === 0) {
+    return;
+  }
+  const stateDirectory = resolveBestStateDirectory2(options);
+  await mkdir2(stateDirectory, { recursive: true });
+  await appendFile(join4(stateDirectory, bestEventsFileName), `${bestEvents.map(serializeBestEvent).join(`
+`)}
+`, "utf8");
+}
+function serializeBestEvent(bestEvent) {
+  return JSON.stringify({
+    metric: bestEvent.metric,
+    previousValue: bestEvent.previousValue,
+    value: bestEvent.value,
+    observedAt: bestEvent.observedAt.toISOString(),
+    windowStart: bestEvent.windowStart.toISOString(),
+    windowEnd: bestEvent.windowEnd.toISOString(),
+    version: bestEvent.version
+  });
+}
+function resolveBestStateDirectory2(options) {
+  return options.stateDirectory ?? join4(homedir4(), ".idletime");
+}
+
+// src/best-metrics/build-rolling-24h-windows.ts
+function findBestRollingWindowTotal(weightedPoints) {
+  const sortedPoints = weightedPoints.filter((point) => point.value > 0).slice().sort((leftPoint, rightPoint) => leftPoint.timestamp.getTime() - rightPoint.timestamp.getTime());
+  if (sortedPoints.length === 0) {
+    return null;
+  }
+  let bestValue = 0;
+  let bestTimestampMs = 0;
+  let currentTotal = 0;
+  let leftIndex = 0;
+  for (let rightIndex = 0;rightIndex < sortedPoints.length; rightIndex += 1) {
+    const rightPoint = sortedPoints[rightIndex];
+    currentTotal += rightPoint.value;
+    while (rightPoint.timestamp.getTime() - sortedPoints[leftIndex].timestamp.getTime() > rollingWindowDurationMs) {
+      currentTotal -= sortedPoints[leftIndex].value;
+      leftIndex += 1;
+    }
+    if (currentTotal > bestValue) {
+      bestValue = currentTotal;
+      bestTimestampMs = rightPoint.timestamp.getTime();
+    }
+  }
+  if (bestValue === 0) {
+    return null;
+  }
+  return createRollingRecord(bestValue, bestTimestampMs);
+}
+function findBestRollingWindowOverlap(intervals) {
+  const slopeChanges = intervals.flatMap(buildSlopeChanges);
+  if (slopeChanges.length === 0) {
+    return null;
+  }
+  slopeChanges.sort((leftChange, rightChange) => leftChange.timestampMs - rightChange.timestampMs);
+  let bestTimestampMs = 0;
+  let bestValue = 0;
+  let currentSlope = 0;
+  let currentValue = 0;
+  let previousTimestampMs = slopeChanges[0].timestampMs;
+  let index = 0;
+  while (index < slopeChanges.length) {
+    const timestampMs = slopeChanges[index].timestampMs;
+    currentValue += currentSlope * (timestampMs - previousTimestampMs);
+    if (currentValue > bestValue) {
+      bestValue = currentValue;
+      bestTimestampMs = timestampMs;
+    }
+    while (index < slopeChanges.length && slopeChanges[index].timestampMs === timestampMs) {
+      currentSlope += slopeChanges[index].deltaSlope;
+      index += 1;
+    }
+    previousTimestampMs = timestampMs;
+  }
+  if (bestValue === 0) {
+    return null;
+  }
+  return createRollingRecord(bestValue, bestTimestampMs);
+}
+function buildSlopeChanges(interval) {
+  const startMs = interval.start.getTime();
+  const endMs = interval.end.getTime();
+  if (endMs <= startMs) {
+    return [];
+  }
+  return [
+    { timestampMs: startMs, deltaSlope: 1 },
+    { timestampMs: endMs, deltaSlope: -1 },
+    { timestampMs: startMs + rollingWindowDurationMs, deltaSlope: -1 },
+    { timestampMs: endMs + rollingWindowDurationMs, deltaSlope: 1 }
+  ];
+}
+function createRollingRecord(value, observedAtMs) {
+  return {
+    value,
+    observedAt: new Date(observedAtMs),
+    windowStart: new Date(observedAtMs - rollingWindowDurationMs),
+    windowEnd: new Date(observedAtMs)
+  };
+}
+
+// src/best-metrics/build-best-metrics.ts
+function buildBestMetricCandidates(sessions, options = {}) {
+  const idleCutoffMs = options.idleCutoffMs ?? defaultBestMetricsIdleCutoffMs;
+  const activityMetrics = buildActivityMetrics(sessions, idleCutoffMs);
+  return {
+    bestConcurrentAgents: findBestConcurrentAgents(activityMetrics.perAgentTaskBlocks),
+    best24hRawBurn: findBestRollingWindowTotal(sessions.flatMap((session) => buildTokenDeltaPoints(session.tokenPoints).map((tokenDeltaPoint) => ({
+      timestamp: tokenDeltaPoint.timestamp,
+      value: tokenDeltaPoint.deltaUsage.totalTokens
+    })))),
+    best24hAgentSumMs: findBestRollingWindowOverlap(activityMetrics.perAgentTaskBlocks.flatMap((taskBlocks) => taskBlocks))
+  };
+}
+function findBestConcurrentAgents(intervalGroups) {
+  const concurrencyEdges = intervalGroups.flatMap((intervalGroup) => intervalGroup.flatMap((interval) => [
+    { timestampMs: interval.start.getTime(), delta: 1 },
+    { timestampMs: interval.end.getTime(), delta: -1 }
+  ]));
+  if (concurrencyEdges.length === 0) {
+    return null;
+  }
+  concurrencyEdges.sort((leftEdge, rightEdge) => leftEdge.timestampMs - rightEdge.timestampMs);
+  let activeCount = 0;
+  let bestRecord = null;
+  let index = 0;
+  while (index < concurrencyEdges.length) {
+    const timestampMs = concurrencyEdges[index].timestampMs;
+    while (index < concurrencyEdges.length && concurrencyEdges[index].timestampMs === timestampMs) {
+      activeCount += concurrencyEdges[index].delta;
+      index += 1;
+    }
+    const nextTimestampMs = concurrencyEdges[index]?.timestampMs ?? timestampMs;
+    if (nextTimestampMs <= timestampMs || activeCount <= 0) {
+      continue;
+    }
+    if (!bestRecord || activeCount > bestRecord.value) {
+      bestRecord = {
+        value: activeCount,
+        observedAt: new Date(timestampMs),
+        windowStart: new Date(timestampMs),
+        windowEnd: new Date(nextTimestampMs)
+      };
+    }
+  }
+  return bestRecord;
+}
+
+// src/best-metrics/read-all-codex-sessions.ts
+import { readdir as readdir2 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+var defaultSessionRootDirectory2 = join5(homedir5(), ".codex", "sessions");
+async function readAllCodexSessions(options = {}) {
+  const sessionRootDirectory = options.sessionRootDirectory ?? defaultSessionRootDirectory2;
+  const sessionFiles = await listAllSessionFiles(sessionRootDirectory);
+  const parsedSessionResults = await Promise.allSettled(sessionFiles.map((sessionFilePath) => parseCodexSession(sessionFilePath)));
+  const parsedSessions = parsedSessionResults.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+  return parsedSessions.sort((leftSession, rightSession) => leftSession.firstTimestamp.getTime() - rightSession.firstTimestamp.getTime());
+}
+async function listAllSessionFiles(rootDirectory) {
+  const pendingDirectories = [rootDirectory];
+  const sessionFiles = [];
+  while (pendingDirectories.length > 0) {
+    const currentDirectory = pendingDirectories.pop();
+    const directoryEntries = await readDirectoryEntries2(currentDirectory);
+    for (const directoryEntry of directoryEntries) {
+      const entryPath = join5(currentDirectory, directoryEntry.name);
+      if (directoryEntry.isDirectory()) {
+        pendingDirectories.push(entryPath);
+        continue;
+      }
+      if (directoryEntry.isFile() && directoryEntry.name.endsWith(".jsonl")) {
+        sessionFiles.push(entryPath);
+      }
+    }
+  }
+  return sessionFiles.sort();
+}
+async function readDirectoryEntries2(directoryPath) {
+  try {
+    return await readdir2(directoryPath, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingDirectoryError2(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function isMissingDirectoryError2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/best-metrics/write-best-ledger.ts
+import { mkdir as mkdir3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+async function writeBestLedger(ledger, options = {}) {
+  const ledgerPath = resolveBestLedgerPath(options);
+  const stateDirectory = options.stateDirectory ?? ledgerPath.slice(0, ledgerPath.lastIndexOf("/"));
+  await mkdir3(stateDirectory, { recursive: true });
+  const temporaryPath = join6(stateDirectory, `.bests-v1.${process.pid}.${Date.now()}.tmp`);
+  await writeFile2(temporaryPath, serializeBestLedger(ledger), "utf8");
+  await rename2(temporaryPath, ledgerPath);
+}
+
+// src/best-metrics/refresh-best-metrics.ts
+async function refreshBestMetrics(options = {}) {
+  const refreshedAt = options.now ?? new Date;
+  const existingLedger = await readBestLedger(options);
+  const sessions = await readAllCodexSessions({
+    sessionRootDirectory: options.sessionRootDirectory
+  });
+  const bestMetricCandidates = buildBestMetricCandidates(sessions);
+  const currentMetrics = buildCurrentBestMetricValues(sessions, {
+    now: refreshedAt
+  });
+  if (!existingLedger) {
+    const bootstrappedLedger = {
+      version: bestMetricsLedgerVersion,
+      initializedAt: refreshedAt,
+      lastScannedAt: refreshedAt,
+      ...bestMetricCandidates
+    };
+    await writeBestLedger(bootstrappedLedger, options);
+    return {
+      currentMetrics,
+      ledger: bootstrappedLedger,
+      newBestEvents: [],
+      refreshMode: "bootstrap"
+    };
+  }
+  const newBestEvents = buildNewBestEvents(existingLedger, bestMetricCandidates);
+  const refreshedLedger = {
+    ...existingLedger,
+    lastScannedAt: refreshedAt,
+    ...mergeBestMetricCandidates(existingLedger, bestMetricCandidates)
+  };
+  await writeBestLedger(refreshedLedger, options);
+  await appendBestEvents(newBestEvents, options);
+  return {
+    currentMetrics,
+    ledger: refreshedLedger,
+    newBestEvents,
+    refreshMode: "refresh"
+  };
+}
+function mergeBestMetricCandidates(currentLedger, candidateLedger) {
+  return {
+    bestConcurrentAgents: pickBetterRecord(currentLedger.bestConcurrentAgents, candidateLedger.bestConcurrentAgents),
+    best24hRawBurn: pickBetterRecord(currentLedger.best24hRawBurn, candidateLedger.best24hRawBurn),
+    best24hAgentSumMs: pickBetterRecord(currentLedger.best24hAgentSumMs, candidateLedger.best24hAgentSumMs)
+  };
+}
+function pickBetterRecord(currentRecord, candidateRecord) {
+  if (!candidateRecord) {
+    return currentRecord;
+  }
+  if (!currentRecord || candidateRecord.value > currentRecord.value) {
+    return candidateRecord;
+  }
+  return currentRecord;
+}
+function buildNewBestEvents(currentLedger, candidateLedger) {
+  return [
+    buildNewBestEvent("bestConcurrentAgents", currentLedger.bestConcurrentAgents, candidateLedger.bestConcurrentAgents),
+    buildNewBestEvent("best24hRawBurn", currentLedger.best24hRawBurn, candidateLedger.best24hRawBurn),
+    buildNewBestEvent("best24hAgentSumMs", currentLedger.best24hAgentSumMs, candidateLedger.best24hAgentSumMs)
+  ].flatMap((bestEvent) => bestEvent ? [bestEvent] : []);
+}
+function buildNewBestEvent(metric, currentRecord, candidateRecord) {
+  if (!candidateRecord || currentRecord !== null && candidateRecord.value <= currentRecord.value) {
+    return null;
+  }
+  return {
+    metric,
+    previousValue: currentRecord?.value ?? null,
+    value: candidateRecord.value,
+    observedAt: candidateRecord.observedAt,
+    windowStart: candidateRecord.windowStart,
+    windowEnd: candidateRecord.windowEnd,
+    version: bestMetricsLedgerVersion
+  };
+}
+
+// src/cli/run-refresh-bests-command.ts
+async function runRefreshBestsCommand(options = {}) {
+  const refreshedBestMetrics = await refreshBestMetrics(options);
+  await notifyBestEvents(refreshedBestMetrics.newBestEvents, options);
+  await notifyNearBestMetrics(refreshedBestMetrics.currentMetrics, refreshedBestMetrics.ledger, options);
+  return [
+    "BEST metrics refreshed",
+    `mode: ${refreshedBestMetrics.refreshMode}`,
+    `new bests: ${refreshedBestMetrics.newBestEvents.length}`,
+    `last scanned: ${refreshedBestMetrics.ledger.lastScannedAt.toISOString()}`
+  ].join(`
+`);
+}
+
+// src/cli/run-today-command.ts
+async function buildTodayCommandResult(command, options = {}) {
+  const window = resolveTodayReportWindow({ now: options.now });
+  const bestLedgerPromise = readBestLedger({ stateDirectory: options.stateDirectory });
+  const sessionsPromise = readCodexSessions({
+    windowStart: window.start,
+    windowEnd: window.end,
+    sessionRootDirectory: options.sessionRootDirectory
+  });
+  const [bestLedger, sessions] = await Promise.all([
+    bestLedgerPromise,
+    sessionsPromise
+  ]);
+  return {
+    bestLedger,
+    summaryReport: buildSummaryReport(sessions, {
+      filters: command.filters,
+      groupBy: command.groupBy,
+      idleCutoffMs: command.idleCutoffMs,
+      wakeWindow: command.wakeWindow,
+      window
+    })
+  };
+}
+async function runTodayCommand(command, options = {}) {
+  const commandResult = await buildTodayCommandResult(command, options);
+  return renderSummaryReport(commandResult.summaryReport, createRenderOptions(command.shareMode), undefined, commandResult.bestLedger ? buildBestPlaque(commandResult.bestLedger) : null);
+}
+
+// src/cli/run-idletime.ts
+async function runIdletimeCli(argv) {
+  const command = parseIdletimeCommand(argv);
+  if (command.helpRequested) {
+    console.log(renderHelpText());
+    return;
+  }
+  if (command.versionRequested) {
+    console.log(package_default.version);
+    return;
+  }
+  if (command.commandName === "refresh-bests") {
+    console.log(await runRefreshBestsCommand());
+    return;
+  }
+  if (command.outputFormat === "json") {
+    console.log(await buildJsonOutput(command));
+    return;
+  }
+  if (command.commandName === "live") {
+    await runLiveCommand(command);
+    return;
+  }
+  const output = command.commandName === "hourly" ? await runHourlyCommand(command) : command.commandName === "today" ? await runTodayCommand(command) : await runLast24hCommand(command);
   console.log(output);
 }
+async function buildJsonOutput(command) {
+  const generatedAt = new Date;
+  if (command.commandName === "live") {
+    const liveSnapshot = await takeLiveSnapshot(command, {
+      observedAt: generatedAt
+    });
+    return serializeLiveSnapshot({
+      command: buildJsonLiveSnapshotCommand(command),
+      generatedAt,
+      liveReport: liveSnapshot
+    });
+  }
+  if (command.commandName === "hourly") {
+    const commandResult2 = await buildHourlyCommandResult(command, {
+      now: generatedAt
+    });
+    return serializeHourlySnapshot({
+      command: buildJsonHourlySnapshotCommand(command),
+      generatedAt,
+      hourlyReport: commandResult2.hourlyReport
+    });
+  }
+  if (command.commandName === "today") {
+    const commandResult2 = await buildTodayCommandResult(command, {
+      now: generatedAt
+    });
+    return serializeSummarySnapshot({
+      command: buildJsonSummarySnapshotCommand(command),
+      generatedAt,
+      hourlyReport: null,
+      mode: "today",
+      summaryReport: commandResult2.summaryReport
+    });
+  }
+  const commandResult = await buildLast24hCommandResult(command, {
+    now: generatedAt
+  });
+  return serializeSummarySnapshot({
+    command: buildJsonSummarySnapshotCommand(command),
+    generatedAt,
+    hourlyReport: commandResult.hourlyReport,
+    mode: "last24h",
+    summaryReport: commandResult.summaryReport
+  });
+}
+function buildJsonSummarySnapshotCommand(command) {
+  return {
+    idleCutoffMs: command.idleCutoffMs,
+    filters: { ...command.filters },
+    groupBy: [...command.groupBy],
+    wakeWindow: command.wakeWindow ? { ...command.wakeWindow } : null
+  };
+}
+function buildJsonHourlySnapshotCommand(command) {
+  return {
+    idleCutoffMs: command.idleCutoffMs,
+    filters: { ...command.filters },
+    wakeWindow: command.wakeWindow ? { ...command.wakeWindow } : null
+  };
+}
+function buildJsonLiveSnapshotCommand(command) {
+  return {
+    filters: { ...command.filters }
+  };
+}
 
 // src/cli/idletime-bin.ts
 await runIdletimeCli(process.argv.slice(2));