idletime 0.1.3 → 0.2.0

package/dist/idletime.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "idletime",
-  version: "0.1.3",
+  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",
@@ -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);
@@ -1256,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));
@@ -1282,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;
@@ -1291,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)
   ];
@@ -1299,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)}`;
 }
@@ -1353,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));
@@ -1382,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));
@@ -1408,985 +1862,1410 @@ 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
+    })
+  };
 }
-
-// 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 runHourlyCommand(command, options = {}) {
+  const commandResult = await buildHourlyCommandResult(command, options);
+  return renderHourlyReport(commandResult.hourlyReport, createRenderOptions(command.shareMode));
 }
-async function sendMacOsNotification(notification) {
-  const notificationIconPath = resolveNotificationIconPath();
+
+// 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 {
-    await execFileAsync("terminal-notifier", [
-      "-title",
-      notification.title,
-      "-message",
-      notification.body,
-      ...notificationIconPath ? ["-appIcon", pathToFileURL(notificationIconPath).href] : []
-    ]);
-    return;
+    const rawLedgerText = await readFile2(resolveBestLedgerPath(options), "utf8");
+    return parseBestLedger(JSON.parse(rawLedgerText));
   } catch (error) {
-    if (!isCommandMissingError(error)) {
-      throw error;
+    if (isMissingFileError(error)) {
+      return null;
     }
+    throw error;
   }
-  await execFileAsync("osascript", [
-    "-e",
-    `display notification "${escapeAppleScriptText(notification.body)}" with title "${escapeAppleScriptText(notification.title)}"`
-  ]);
 }
-function escapeAppleScriptText(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+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 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 resolveBestLedgerPath(options = {}) {
+  return join2(resolveBestStateDirectory(options), bestLedgerFileName);
 }
-function isCommandMissingError(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+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)}
+`;
 }
-
-// src/best-metrics/near-best-notifications.ts
-import { mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } 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 [];
+function parseBestMetricRecord(value, label) {
+  if (value === null || value === undefined) {
+    return null;
   }
-  const nextState = {
-    ...state,
-    lastNotifiedAt: {
-      ...state.lastNotifiedAt,
-      ...Object.fromEntries(metricsToNotify.map((metric) => [metric, now]))
-    }
+  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`)
   };
-  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 readFile2(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}.`);
+function serializeBestMetricRecord(record) {
+  if (!record) {
+    return null;
   }
-  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")
-    }
+    value: record.value,
+    observedAt: record.observedAt.toISOString(),
+    windowStart: record.windowStart.toISOString(),
+    windowEnd: record.windowEnd.toISOString()
   };
 }
-async function writeNearBestNotificationState(state, options) {
-  const statePath = resolveNearBestNotificationStatePath(options);
-  const stateDirectory = options.stateDirectory ?? join2(homedir2(), ".idletime");
-  await mkdir(stateDirectory, { recursive: true });
-  const temporaryPath = join2(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 resolveBestStateDirectory(options) {
+  return options.stateDirectory ?? join2(homedir2(), ".idletime");
 }
-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 isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function buildNearBestNotification(metric, currentValue, bestValue) {
+
+// src/reporting/build-summary-report.ts
+function buildSummaryReport(sessions, query) {
+  const filteredSessions = filterSessions(sessions, query.filters);
+  const windowInterval = {
+    start: query.window.start,
+    end: query.window.end
+  };
+  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(filteredSessions, query.idleCutoffMs, query.window.end), windowInterval);
+  const comparisonCutoffMs = parseDurationToMs("30m");
+  const sessionCounts = {
+    total: filteredSessions.length,
+    direct: filteredSessions.filter((session) => session.kind === "direct").length,
+    subagent: filteredSessions.filter((session) => session.kind === "subagent").length
+  };
   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`
+    activityWindow: resolveActivityWindow(filteredSessions, windowInterval),
+    appliedFilters: query.filters,
+    comparisonCutoffMs,
+    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,
+    metrics,
+    sessionCounts,
+    tokenTotals: sumTokenTotals(filteredSessions, windowInterval),
+    wakeSummary: query.wakeWindow ? summarizeWakeWindow(query.wakeWindow, query.window, metrics) : null,
+    window: query.window
   };
 }
-function createDefaultNearBestNotificationState() {
+function buildGroupBreakdowns(sessions, dimensions, idleCutoffMs, windowInterval) {
+  return dimensions.map((dimension) => ({
+    dimension,
+    rows: groupSessions(sessions, dimension).map((groupedSessions) => buildGroupRow(groupedSessions.key, groupedSessions.sessions, idleCutoffMs, windowInterval, windowInterval.end))
+  }));
+}
+function buildGroupRow(key, sessions, idleCutoffMs, windowInterval, observedAt) {
+  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(sessions, idleCutoffMs, observedAt), windowInterval);
+  const tokenTotals = sumTokenTotals(sessions, windowInterval);
   return {
-    version: nearBestNotificationVersion,
-    nearBestEnabled: false,
-    thresholdRatio: 0.97,
-    cooldownMs: 24 * 60 * 60 * 1000,
-    lastNotifiedAt: {
-      bestConcurrentAgents: null,
-      best24hRawBurn: null,
-      best24hAgentSumMs: null
-    }
+    key,
+    sessionCount: sessions.length,
+    directActivityMs: metrics.directActivityMs,
+    agentCoverageMs: metrics.agentCoverageMs,
+    cumulativeAgentMs: metrics.cumulativeAgentMs,
+    practicalBurn: tokenTotals.practicalBurn,
+    rawTotalTokens: tokenTotals.rawTotalTokens
   };
 }
-function resolveNearBestNotificationStatePath(options) {
-  return join2(options.stateDirectory ?? join2(homedir2(), ".idletime"), nearBestNotificationStateFileName);
+function sumTokenTotals(sessions, windowInterval) {
+  return sessions.reduce((tokenTotals, session) => {
+    const sessionWindowTotals = buildTokenDeltaPoints(session.tokenPoints).filter((tokenDeltaPoint) => tokenDeltaPoint.timestamp.getTime() >= windowInterval.start.getTime() && tokenDeltaPoint.timestamp.getTime() <= windowInterval.end.getTime()).reduce((sessionTotals, tokenDeltaPoint) => ({
+      practicalBurn: sessionTotals.practicalBurn + tokenDeltaPoint.deltaUsage.practicalBurn,
+      rawTotalTokens: sessionTotals.rawTotalTokens + tokenDeltaPoint.deltaUsage.totalTokens
+    }), { practicalBurn: 0, rawTotalTokens: 0 });
+    return {
+      practicalBurn: tokenTotals.practicalBurn + sessionWindowTotals.practicalBurn,
+      rawTotalTokens: tokenTotals.rawTotalTokens + sessionWindowTotals.rawTotalTokens
+    };
+  }, {
+    practicalBurn: 0,
+    rawTotalTokens: 0
+  });
 }
-function readOptionalIsoTimestamp(value, label) {
-  if (value === null || value === undefined) {
+function resolveActivityWindow(sessions, windowInterval) {
+  if (sessions.length === 0) {
     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) {
+  const firstTimestamp = sessions.reduce((earliestTimestamp, session) => session.firstTimestamp.getTime() < earliestTimestamp.getTime() ? session.firstTimestamp : earliestTimestamp, sessions[0].firstTimestamp);
+  const lastTimestamp = sessions.reduce((latestTimestamp, session) => session.lastTimestamp.getTime() > latestTimestamp.getTime() ? session.lastTimestamp : latestTimestamp, sessions[0].lastTimestamp);
   return {
-    title: resolveNotificationTitle(bestEvent.metric),
-    body: resolveNotificationBody(bestEvent)
+    start: new Date(Math.max(firstTimestamp.getTime(), windowInterval.start.getTime())),
+    end: new Date(Math.min(lastTimestamp.getTime(), windowInterval.end.getTime()))
   };
 }
-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/types.ts
-var bestMetricsLedgerVersion = 1;
-var rollingWindowDurationMs = 24 * 60 * 60 * 1000;
-var defaultBestMetricsIdleCutoffMs = 15 * 60 * 1000;
-
-// 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);
-  const currentWindow = {
-    start: new Date(now.getTime() - rollingWindowDurationMs),
-    end: now
-  };
+function clipActivityMetricsToWindow(metrics, windowInterval) {
+  const strictEngagementBlocks = intersectTimeIntervals(metrics.strictEngagementBlocks, [windowInterval]);
+  const directActivityBlocks = intersectTimeIntervals(metrics.directActivityBlocks, [windowInterval]);
+  const agentCoverageBlocks = intersectTimeIntervals(metrics.agentCoverageBlocks, [windowInterval]);
+  const agentOnlyBlocks = intersectTimeIntervals(metrics.agentOnlyBlocks, [windowInterval]);
+  const perAgentTaskBlocks = metrics.perAgentTaskBlocks.map((taskBlocks) => intersectTimeIntervals(taskBlocks, [windowInterval]));
   return {
-    bestConcurrentAgents: countLiveSubagents(activityMetrics.perSubagentBlocks, 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.perSubagentBlocks.flatMap((sessionBlocks) => sessionBlocks), currentWindow)
+    strictEngagementBlocks,
+    directActivityBlocks,
+    agentCoverageBlocks,
+    agentOnlyBlocks,
+    perAgentTaskBlocks,
+    strictEngagementMs: sumTimeIntervalsMs(strictEngagementBlocks),
+    directActivityMs: sumTimeIntervalsMs(directActivityBlocks),
+    agentCoverageMs: sumTimeIntervalsMs(agentCoverageBlocks),
+    agentOnlyMs: sumTimeIntervalsMs(agentOnlyBlocks),
+    cumulativeAgentMs: perAgentTaskBlocks.reduce((totalDurationMs, taskBlocks) => totalDurationMs + sumTimeIntervalsMs(taskBlocks), 0),
+    peakConcurrentAgents: peakConcurrency(perAgentTaskBlocks)
   };
 }
-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 homedir3 } from "node:os";
-import { join as join3 } from "node:path";
-var bestEventsFileName = "best-events.ndjson";
-async function appendBestEvents(bestEvents, options = {}) {
-  if (bestEvents.length === 0) {
-    return;
+// src/reporting/render-summary-report.ts
+var summaryBarWidth = 18;
+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, bestPlaque = null) {
+  const lines = [];
+  const requestedMetrics = report.metrics;
+  const actualComparisonMetrics = report.comparisonMetrics;
+  const windowDurationMs = report.window.end.getTime() - report.window.start.getTime();
+  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, bestPlaque));
+  lines.push("");
+  lines.push(...panelLines);
+  if (hourlyReport) {
+    lines.push("");
+    lines.push(...buildAgentSection(hourlyReport, options));
+    lines.push("");
+    lines.push(...buildRhythmSection(hourlyReport, options));
   }
-  const stateDirectory = resolveBestStateDirectory(options);
-  await mkdir2(stateDirectory, { recursive: true });
-  await appendFile(join3(stateDirectory, bestEventsFileName), `${bestEvents.map(serializeBestEvent).join(`
-`)}
-`, "utf8");
+  lines.push("");
+  lines.push(...renderSectionTitle("Activity", options));
+  lines.push(renderMetricRow("strict", requestedMetrics.strictEngagementMs, windowDurationMs, formatDurationHours(requestedMetrics.strictEngagementMs), `${formatSignedDurationHours(actualComparisonMetrics.strictEngagementMs - requestedMetrics.strictEngagementMs)} at ${formatDurationLabel(report.comparisonCutoffMs)}`, "█", "focus", options));
+  lines.push(renderMetricRow("direct", requestedMetrics.directActivityMs, windowDurationMs, formatDurationHours(requestedMetrics.directActivityMs), `${formatSignedDurationHours(actualComparisonMetrics.directActivityMs - requestedMetrics.directActivityMs)} at ${formatDurationLabel(report.comparisonCutoffMs)}`, "▓", "active", options));
+  lines.push(renderMetricRow("agent live", requestedMetrics.agentCoverageMs, windowDurationMs, formatDurationHours(requestedMetrics.agentCoverageMs), "coverage", "▒", "agent", options));
+  lines.push(renderMetricRow("agent sum", requestedMetrics.cumulativeAgentMs, Math.max(windowDurationMs, requestedMetrics.cumulativeAgentMs), formatDurationHours(requestedMetrics.cumulativeAgentMs), `peak ${requestedMetrics.peakConcurrentAgents} concurrent`, "▚", "agent", options));
+  lines.push(`${paint(padRight("  session mix", 14), "muted", options)} ${paint(buildSplitBar([
+    {
+      filledCharacter: "█",
+      value: report.sessionCounts.direct
+    },
+    {
+      filledCharacter: "▓",
+      value: report.sessionCounts.subagent
+    }
+  ], summaryBarWidth), "active", options)}  ${paint(`${report.sessionCounts.direct} direct / ${report.sessionCounts.subagent} subagent`, "value", options)}`);
+  lines.push("");
+  lines.push(...renderSectionTitle("Tokens", options));
+  const maxBurnValue = Math.max(report.tokenTotals.practicalBurn, report.directTokenTotals.practicalBurn);
+  const maxRawValue = Math.max(report.tokenTotals.rawTotalTokens, report.directTokenTotals.rawTotalTokens);
+  lines.push(renderMetricRow("practical burn", report.tokenTotals.practicalBurn, maxBurnValue, formatCompactInteger(report.tokenTotals.practicalBurn), `${formatPercentage(report.tokenTotals.practicalBurn / report.tokenTotals.rawTotalTokens)} of raw`, "█", "burn", options, "burn"));
+  lines.push(renderMetricRow("all raw", report.tokenTotals.rawTotalTokens, maxRawValue, formatCompactInteger(report.tokenTotals.rawTotalTokens), `${formatInteger(report.tokenTotals.rawTotalTokens)} total`, "█", "raw", options, "raw"));
+  lines.push(renderMetricRow("direct burn", report.directTokenTotals.practicalBurn, maxBurnValue, formatCompactInteger(report.directTokenTotals.practicalBurn), `${formatPercentage(report.directTokenTotals.practicalBurn / report.tokenTotals.practicalBurn)} of burn`, "▒", "burn", options, "burn"));
+  lines.push(renderMetricRow("direct raw", report.directTokenTotals.rawTotalTokens, maxRawValue, formatCompactInteger(report.directTokenTotals.rawTotalTokens), `${formatPercentage(report.directTokenTotals.rawTotalTokens / report.tokenTotals.rawTotalTokens)} of raw`, "▒", "raw", options, "raw"));
+  if (report.wakeSummary) {
+    lines.push("");
+    lines.push(...renderSectionTitle("Wake Window", options));
+    lines.push(renderMetricRow("direct awake", report.wakeSummary.directActivityMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.directActivityMs), `of ${formatDurationClock(report.wakeSummary.wakeDurationMs)} wake`, "▓", "active", options));
+    lines.push(renderMetricRow("strict awake", report.wakeSummary.strictEngagementMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.strictEngagementMs), "engaged", "█", "focus", options));
+    lines.push(renderMetricRow("agent awake", report.wakeSummary.agentOnlyMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.agentOnlyMs), "agent-only", "▒", "agent", options));
+    lines.push(renderMetricRow("awake idle", report.wakeSummary.awakeIdleMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.awakeIdleMs), `${formatPercentage(report.wakeSummary.awakeIdlePercentage)} idle`, "░", "idle", options));
+    lines.push(`${paint(padRight("  longest gap", 14), "muted", options)} ${paint(formatDurationClock(report.wakeSummary.longestIdleGapMs), "value", options)}  ${dim("largest quiet stretch", options)}`);
+  }
+  for (const groupBreakdown of report.groupBreakdowns) {
+    lines.push("");
+    lines.push(...renderSectionTitle(groupBreakdown.dimension === "model" ? "Model Breakdown" : "Effort Breakdown", options));
+    const maxBreakdownBurn = Math.max(...groupBreakdown.rows.map((row) => row.practicalBurn), 0);
+    for (const row of groupBreakdown.rows) {
+      lines.push(`${paint(padRight(`  ${row.key}`, 20), "muted", options)} ${paint(buildBar(row.practicalBurn, maxBreakdownBurn, 14, "█"), "burn", options)}  ${paint(padRight(formatCompactInteger(row.practicalBurn), 6), "value", options)} ${dim("burn", options)}  ${paint(padRight(formatDurationCompact(row.directActivityMs), 5), "active", options)} ${dim("direct", options)}  ${paint(padRight(formatDurationCompact(row.agentCoverageMs), 5), "agent", options)} ${dim("live", options)}  ${paint(`${row.sessionCount} s`, "value", options)}`);
+    }
+  }
+  return lines.join(`
+`);
 }
-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 renderShareSummaryReport(report, options, hourlyReport, bestPlaque = null) {
+  const lines = [];
+  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, bestPlaque));
+  lines.push("");
+  lines.push(...panelLines);
+  if (hourlyReport) {
+    lines.push("");
+    lines.push(...buildAgentSection(hourlyReport, options));
+    lines.push("");
+    lines.push(...buildRhythmSection(hourlyReport, options));
+  }
+  lines.push("");
+  lines.push(...renderSectionTitle("Snapshot", options));
+  lines.push(renderSnapshotRow("focus", formatDurationHours(report.metrics.strictEngagementMs), "focused time", "focus", options));
+  lines.push(renderSnapshotRow("active", formatDurationHours(report.metrics.directActivityMs), "direct-session movement", "active", options));
+  lines.push(renderSnapshotRow(report.wakeSummary ? "idle" : "quiet", report.wakeSummary ? formatDurationClock(report.wakeSummary.awakeIdleMs) : hourlyReport ? formatDurationCompact(hourlyReport.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs), 0)) : "n/a", report.wakeSummary ? "awake idle" : "quiet hours", "idle", options));
+  lines.push(renderSnapshotRow("burn", formatCompactInteger(report.tokenTotals.practicalBurn), `${formatPercentage(report.tokenTotals.practicalBurn / report.tokenTotals.rawTotalTokens)} of raw`, "burn", options));
+  lines.push(renderSnapshotRow("agents", `${report.metrics.peakConcurrentAgents} peak`, `${formatDurationHours(report.metrics.cumulativeAgentMs)} cumulative`, "agent", options));
+  lines.push(renderSnapshotRow("sessions", `${report.sessionCounts.total}`, `${report.sessionCounts.direct} direct / ${report.sessionCounts.subagent} subagent`, "value", options));
+  return lines.join(`
+`);
+}
+function formatAppliedFilters(report) {
+  const appliedFilters = [];
+  if (report.appliedFilters.workspaceOnlyPrefix) {
+    appliedFilters.push(`workspace=${shortenPath(report.appliedFilters.workspaceOnlyPrefix, 48)}`);
+  }
+  if (report.appliedFilters.sessionKind) {
+    appliedFilters.push(`kind=${report.appliedFilters.sessionKind}`);
+  }
+  if (report.appliedFilters.model) {
+    appliedFilters.push(`model=${report.appliedFilters.model}`);
+  }
+  if (report.appliedFilters.reasoningEffort) {
+    appliedFilters.push(`effort=${report.appliedFilters.reasoningEffort}`);
+  }
+  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`;
+}
+function renderMetricRow(label, value, maxValue, primaryText, detailText, filledCharacter, role, options, valueRole = "value") {
+  return `${paint(padRight(`  ${label}`, 14), "muted", options)} ${paint(buildBar(value, maxValue, summaryBarWidth, filledCharacter), role, options)}  ${paint(padRight(primaryText, 7), valueRole, options)} ${dim(detailText, options)}`;
+}
+function renderSnapshotRow(label, primaryText, detailText, role, options) {
+  return `${paint(padRight(`  ${label}`, 12), role, options)} ${paint(padRight(primaryText, 10), "value", options)} ${dim(detailText, options)}`;
+}
+
+// src/cli/run-last24h-command.ts
+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,
+    sessionRootDirectory: options.sessionRootDirectory
+  });
+  const [bestLedger, sessions] = await Promise.all([
+    bestLedgerPromise,
+    sessionsPromise
+  ]);
+  const summaryReport = buildSummaryReport(sessions, {
+    filters: command.filters,
+    groupBy: command.groupBy,
+    idleCutoffMs: command.idleCutoffMs,
+    wakeWindow: command.wakeWindow,
+    window
+  });
+  const hourlyReport = buildHourlyReport(sessions, {
+    filters: command.filters,
+    idleCutoffMs: command.idleCutoffMs,
+    wakeWindow: command.wakeWindow,
+    window
   });
+  return {
+    bestLedger,
+    hourlyReport,
+    summaryReport
+  };
 }
-function resolveBestStateDirectory(options) {
-  return options.stateDirectory ?? join3(homedir3(), ".idletime");
+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/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;
+// 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);
   }
-  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;
+  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);
+  }
+  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 [];
     }
-    if (currentTotal > bestValue) {
-      bestValue = currentTotal;
-      bestTimestampMs = rightPoint.timestamp.getTime();
+    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;
   }
-  if (bestValue === 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;
   }
-  return createRollingRecord(bestValue, bestTimestampMs);
-}
-function findBestRollingWindowOverlap(intervals) {
-  const slopeChanges = intervals.flatMap(buildSlopeChanges);
-  if (slopeChanges.length === 0) {
+  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;
   }
-  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;
+  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 [];
     }
-    while (index < slopeChanges.length && slopeChanges[index].timestampMs === timestampMs) {
-      currentSlope += slopeChanges[index].deltaSlope;
-      index += 1;
+    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 [];
     }
-    previousTimestampMs = timestampMs;
+    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)}`
+    ];
   }
-  if (bestValue === 0) {
-    return null;
+  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 createRollingRecord(bestValue, bestTimestampMs);
+  return lines;
 }
-function buildSlopeChanges(interval) {
-  const startMs = interval.start.getTime();
-  const endMs = interval.end.getTime();
-  if (endMs <= startMs) {
+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 [
-    { timestampMs: startMs, deltaSlope: 1 },
-    { timestampMs: endMs, deltaSlope: -1 },
-    { timestampMs: startMs + rollingWindowDurationMs, deltaSlope: -1 },
-    { timestampMs: endMs + rollingWindowDurationMs, deltaSlope: 1 }
-  ];
+  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 createRollingRecord(value, observedAtMs) {
-  return {
-    value,
-    observedAt: new Date(observedAtMs),
-    windowStart: new Date(observedAtMs - rollingWindowDurationMs),
-    windowEnd: new Date(observedAtMs)
-  };
+function formatLocationLabel(cwd) {
+  if (cwd.endsWith("/.agents")) {
+    return "~/.agents";
+  }
+  return basename(cwd) || shortenPath(cwd, 24);
 }
-
-// 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.perSubagentBlocks),
-    best24hRawBurn: findBestRollingWindowTotal(sessions.flatMap((session) => buildTokenDeltaPoints(session.tokenPoints).map((tokenDeltaPoint) => ({
-      timestamp: tokenDeltaPoint.timestamp,
-      value: tokenDeltaPoint.deltaUsage.totalTokens
-    })))),
-    best24hAgentSumMs: findBestRollingWindowOverlap(activityMetrics.perSubagentBlocks.flatMap((sessionBlocks) => sessionBlocks))
-  };
+function formatThreadLabel(sessionId) {
+  return sessionId.slice(-6);
 }
-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;
+
+// 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;
   }
-  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;
+  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();
     }
-    const nextTimestampMs = concurrencyEdges[index]?.timestampMs ?? timestampMs;
-    if (nextTimestampMs <= timestampMs || activeCount <= 0) {
-      continue;
+  };
+  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();
     }
-    if (!bestRecord || activeCount > bestRecord.value) {
-      bestRecord = {
-        value: activeCount,
-        observedAt: new Date(timestampMs),
-        windowStart: new Date(timestampMs),
-        windowEnd: new Date(nextTimestampMs)
-      };
+  } 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);
   }
-  return bestRecord;
 }
-
-// src/best-metrics/read-all-codex-sessions.ts
-import { readdir as readdir2 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
-var defaultSessionRootDirectory2 = join4(homedir4(), ".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 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
+  });
 }
-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 = join4(currentDirectory, directoryEntry.name);
-      if (directoryEntry.isDirectory()) {
-        pendingDirectories.push(entryPath);
-        continue;
-      }
-      if (directoryEntry.isFile() && directoryEntry.name.endsWith(".jsonl")) {
-        sessionFiles.push(entryPath);
-      }
+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);
   }
-  return sessionFiles.sort();
-}
-async function readDirectoryEntries2(directoryPath) {
-  try {
-    return await readdir2(directoryPath, { withFileTypes: true });
-  } catch (error) {
-    if (isMissingDirectoryError2(error)) {
-      return [];
-    }
-    throw error;
+  for (let lineIndex = frameLines.length;lineIndex < previousFrameLineCount; lineIndex += 1) {
+    process.stdout.write(`
+\r\x1B[2K`);
   }
+  return frameLines.length;
 }
-function isMissingDirectoryError2(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function waitForNextRefresh() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, liveRefreshIntervalMs);
+  });
 }
 
-// src/best-metrics/read-best-ledger.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { join as join5 } from "node:path";
-var bestLedgerFileName = "bests-v1.json";
-async function readBestLedger(options = {}) {
+// 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 {
-    const rawLedgerText = await readFile3(resolveBestLedgerPath(options), "utf8");
-    return parseBestLedger(JSON.parse(rawLedgerText));
+    await execFileAsync("terminal-notifier", [
+      "-title",
+      notification.title,
+      "-message",
+      notification.body,
+      ...notificationIconPath ? ["-appIcon", pathToFileURL(notificationIconPath).href] : []
+    ]);
+    return;
   } catch (error) {
-    if (isMissingFileError(error)) {
-      return null;
+    if (!isCommandMissingError(error)) {
+      throw error;
     }
-    throw error;
   }
+  await execFileAsync("osascript", [
+    "-e",
+    `display notification "${escapeAppleScriptText(notification.body)}" with title "${escapeAppleScriptText(notification.title)}"`
+  ]);
 }
-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 escapeAppleScriptText(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
 }
-function resolveBestLedgerPath(options = {}) {
-  return join5(resolveBestStateDirectory2(options), bestLedgerFileName);
+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 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 isCommandMissingError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function parseBestMetricRecord(value, label) {
-  if (value === null || value === undefined) {
-    return null;
+
+// 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 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`)
+  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 serializeBestMetricRecord(record) {
-  if (!record) {
-    return null;
+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 {
-    value: record.value,
-    observedAt: record.observedAt.toISOString(),
-    windowStart: record.windowStart.toISOString(),
-    windowEnd: record.windowEnd.toISOString()
+    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")
+    }
   };
 }
-function resolveBestStateDirectory2(options) {
-  return options.stateDirectory ?? join5(homedir5(), ".idletime");
-}
-function isMissingFileError(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);
+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);
 }
-
-// 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
+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;
   });
-  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);
+}
+function buildNearBestNotification(metric, currentValue, bestValue) {
   return {
-    currentMetrics,
-    ledger: refreshedLedger,
-    newBestEvents,
-    refreshMode: "refresh"
+    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 mergeBestMetricCandidates(currentLedger, candidateLedger) {
+function createDefaultNearBestNotificationState() {
   return {
-    bestConcurrentAgents: pickBetterRecord(currentLedger.bestConcurrentAgents, candidateLedger.bestConcurrentAgents),
-    best24hRawBurn: pickBetterRecord(currentLedger.best24hRawBurn, candidateLedger.best24hRawBurn),
-    best24hAgentSumMs: pickBetterRecord(currentLedger.best24hAgentSumMs, candidateLedger.best24hAgentSumMs)
+    version: nearBestNotificationVersion,
+    nearBestEnabled: false,
+    thresholdRatio: 0.97,
+    cooldownMs: 24 * 60 * 60 * 1000,
+    lastNotifiedAt: {
+      bestConcurrentAgents: null,
+      best24hRawBurn: null,
+      best24hAgentSumMs: null
+    }
   };
 }
-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 resolveNearBestNotificationStatePath(options) {
+  return join3(options.stateDirectory ?? join3(homedir3(), ".idletime"), nearBestNotificationStateFileName);
 }
-function buildNewBestEvent(metric, currentRecord, candidateRecord) {
-  if (!candidateRecord || currentRecord !== null && candidateRecord.value <= currentRecord.value) {
+function readOptionalIsoTimestamp(value, label) {
+  if (value === null || value === undefined) {
     return null;
   }
-  return {
-    metric,
-    previousValue: currentRecord?.value ?? null,
-    value: candidateRecord.value,
-    observedAt: candidateRecord.observedAt,
-    windowStart: candidateRecord.windowStart,
-    windowEnd: candidateRecord.windowEnd,
-    version: bestMetricsLedgerVersion
-  };
+  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/reporting/build-summary-report.ts
-function buildSummaryReport(sessions, query) {
-  const filteredSessions = filterSessions(sessions, query.filters);
-  const windowInterval = {
-    start: query.window.start,
-    end: query.window.end
-  };
-  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(filteredSessions, query.idleCutoffMs), windowInterval);
-  const comparisonCutoffMs = parseDurationToMs("30m");
-  const sessionCounts = {
-    total: filteredSessions.length,
-    direct: filteredSessions.filter((session) => session.kind === "direct").length,
-    subagent: filteredSessions.filter((session) => session.kind === "subagent").length
-  };
+// src/best-metrics/notify-best-events.ts
+async function notifyBestEvents(bestEvents, options = {}) {
+  await deliverLocalNotifications(bestEvents.map((bestEvent) => buildBestEventNotification(bestEvent)), options);
+}
+function buildBestEventNotification(bestEvent) {
   return {
-    activityWindow: resolveActivityWindow(filteredSessions, windowInterval),
-    appliedFilters: query.filters,
-    comparisonCutoffMs,
-    comparisonMetrics: query.idleCutoffMs === comparisonCutoffMs ? metrics : clipActivityMetricsToWindow(buildActivityMetrics(filteredSessions, comparisonCutoffMs), windowInterval),
-    directTokenTotals: sumTokenTotals(filteredSessions.filter((session) => session.kind === "direct"), windowInterval),
-    groupBreakdowns: buildGroupBreakdowns(filteredSessions, query.groupBy, query.idleCutoffMs, windowInterval),
-    idleCutoffMs: query.idleCutoffMs,
-    metrics,
-    sessionCounts,
-    tokenTotals: sumTokenTotals(filteredSessions, windowInterval),
-    wakeSummary: query.wakeWindow ? summarizeWakeWindow(query.wakeWindow, query.window, metrics) : null,
-    window: query.window
+    title: resolveNotificationTitle(bestEvent.metric),
+    body: resolveNotificationBody(bestEvent)
   };
 }
-function buildGroupBreakdowns(sessions, dimensions, idleCutoffMs, windowInterval) {
-  return dimensions.map((dimension) => ({
-    dimension,
-    rows: groupSessions(sessions, dimension).map((groupedSessions) => buildGroupRow(groupedSessions.key, groupedSessions.sessions, idleCutoffMs, windowInterval))
-  }));
+function resolveNotificationTitle(bestMetricKey) {
+  return bestMetricKey === "bestConcurrentAgents" ? "New best concurrent agents" : bestMetricKey === "best24hRawBurn" ? "New best 24hr raw burn" : "New best agent sum";
 }
-function buildGroupRow(key, sessions, idleCutoffMs, windowInterval) {
-  const metrics = clipActivityMetricsToWindow(buildActivityMetrics(sessions, idleCutoffMs), windowInterval);
-  const tokenTotals = sumTokenTotals(sessions, windowInterval);
-  return {
-    key,
-    sessionCount: sessions.length,
-    directActivityMs: metrics.directActivityMs,
-    agentCoverageMs: metrics.agentCoverageMs,
-    cumulativeAgentMs: metrics.cumulativeAgentMs,
-    practicalBurn: tokenTotals.practicalBurn,
-    rawTotalTokens: tokenTotals.rawTotalTokens
-  };
+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 sumTokenTotals(sessions, windowInterval) {
-  return sessions.reduce((tokenTotals, session) => {
-    const sessionWindowTotals = buildTokenDeltaPoints(session.tokenPoints).filter((tokenDeltaPoint) => tokenDeltaPoint.timestamp.getTime() >= windowInterval.start.getTime() && tokenDeltaPoint.timestamp.getTime() <= windowInterval.end.getTime()).reduce((sessionTotals, tokenDeltaPoint) => ({
-      practicalBurn: sessionTotals.practicalBurn + tokenDeltaPoint.deltaUsage.practicalBurn,
-      rawTotalTokens: sessionTotals.rawTotalTokens + tokenDeltaPoint.deltaUsage.totalTokens
-    }), { practicalBurn: 0, rawTotalTokens: 0 });
-    return {
-      practicalBurn: tokenTotals.practicalBurn + sessionWindowTotals.practicalBurn,
-      rawTotalTokens: tokenTotals.rawTotalTokens + sessionWindowTotals.rawTotalTokens
-    };
-  }, {
-    practicalBurn: 0,
-    rawTotalTokens: 0
-  });
+function formatAgentSumHours3(durationMs) {
+  const hours = durationMs / 3600000;
+  return hours >= 10 ? Math.round(hours).toString() : (Math.round(hours * 10) / 10).toString();
 }
-function resolveActivityWindow(sessions, windowInterval) {
-  if (sessions.length === 0) {
-    return null;
-  }
-  const firstTimestamp = sessions.reduce((earliestTimestamp, session) => session.firstTimestamp.getTime() < earliestTimestamp.getTime() ? session.firstTimestamp : earliestTimestamp, sessions[0].firstTimestamp);
-  const lastTimestamp = sessions.reduce((latestTimestamp, session) => session.lastTimestamp.getTime() > latestTimestamp.getTime() ? session.lastTimestamp : latestTimestamp, sessions[0].lastTimestamp);
-  return {
-    start: new Date(Math.max(firstTimestamp.getTime(), windowInterval.start.getTime())),
-    end: new Date(Math.min(lastTimestamp.getTime(), windowInterval.end.getTime()))
-  };
+function formatCompactInteger3(value) {
+  return new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumFractionDigits: 1
+  }).format(Math.round(value)).toUpperCase();
 }
-function clipActivityMetricsToWindow(metrics, windowInterval) {
-  const strictEngagementBlocks = intersectTimeIntervals(metrics.strictEngagementBlocks, [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]));
+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 {
-    strictEngagementBlocks,
-    directActivityBlocks,
-    agentCoverageBlocks,
-    agentOnlyBlocks,
-    perSubagentBlocks,
-    strictEngagementMs: sumTimeIntervalsMs(strictEngagementBlocks),
-    directActivityMs: sumTimeIntervalsMs(directActivityBlocks),
-    agentCoverageMs: sumTimeIntervalsMs(agentCoverageBlocks),
-    agentOnlyMs: sumTimeIntervalsMs(agentOnlyBlocks),
-    cumulativeAgentMs: perSubagentBlocks.reduce((totalDurationMs, sessionBlocks) => totalDurationMs + sumTimeIntervalsMs(sessionBlocks), 0),
-    peakConcurrentAgents: peakConcurrency(perSubagentBlocks)
+    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/reporting/render-summary-report.ts
-var summaryBarWidth = 18;
-function renderSummaryReport(report, options, hourlyReport, bestPlaque = null) {
-  return options.shareMode ? renderShareSummaryReport(report, options, hourlyReport, bestPlaque) : renderFullSummaryReport(report, options, hourlyReport, bestPlaque);
+// 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 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 = 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, bestPlaque));
-  lines.push("");
-  lines.push(...panelLines);
-  if (hourlyReport) {
-    lines.push("");
-    lines.push(...buildRhythmSection(hourlyReport, options));
+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;
   }
-  lines.push("");
-  lines.push(...renderSectionTitle("Activity", options));
-  lines.push(renderMetricRow("strict", requestedMetrics.strictEngagementMs, windowDurationMs, formatDurationHours(requestedMetrics.strictEngagementMs), `${formatSignedDurationHours(actualComparisonMetrics.strictEngagementMs - requestedMetrics.strictEngagementMs)} at ${formatDurationLabel(report.comparisonCutoffMs)}`, "█", "focus", options));
-  lines.push(renderMetricRow("direct", requestedMetrics.directActivityMs, windowDurationMs, formatDurationHours(requestedMetrics.directActivityMs), `${formatSignedDurationHours(actualComparisonMetrics.directActivityMs - requestedMetrics.directActivityMs)} at ${formatDurationLabel(report.comparisonCutoffMs)}`, "▓", "active", options));
-  lines.push(renderMetricRow("agent live", requestedMetrics.agentCoverageMs, windowDurationMs, formatDurationHours(requestedMetrics.agentCoverageMs), "coverage", "▒", "agent", options));
-  lines.push(renderMetricRow("agent sum", requestedMetrics.cumulativeAgentMs, Math.max(windowDurationMs, requestedMetrics.cumulativeAgentMs), formatDurationHours(requestedMetrics.cumulativeAgentMs), `peak ${requestedMetrics.peakConcurrentAgents} concurrent`, "▚", "agent", options));
-  lines.push(`${paint(padRight("  session mix", 14), "muted", options)} ${paint(buildSplitBar([
-    {
-      filledCharacter: "█",
-      value: report.sessionCounts.direct
-    },
-    {
-      filledCharacter: "▓",
-      value: report.sessionCounts.subagent
+  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;
     }
-  ], summaryBarWidth), "active", options)}  ${paint(`${report.sessionCounts.direct} direct / ${report.sessionCounts.subagent} subagent`, "value", options)}`);
-  lines.push("");
-  lines.push(...renderSectionTitle("Tokens", options));
-  const maxBurnValue = Math.max(report.tokenTotals.practicalBurn, report.directTokenTotals.practicalBurn);
-  const maxRawValue = Math.max(report.tokenTotals.rawTotalTokens, report.directTokenTotals.rawTotalTokens);
-  lines.push(renderMetricRow("practical burn", report.tokenTotals.practicalBurn, maxBurnValue, formatCompactInteger(report.tokenTotals.practicalBurn), `${formatPercentage(report.tokenTotals.practicalBurn / report.tokenTotals.rawTotalTokens)} of raw`, "█", "burn", options, "burn"));
-  lines.push(renderMetricRow("all raw", report.tokenTotals.rawTotalTokens, maxRawValue, formatCompactInteger(report.tokenTotals.rawTotalTokens), `${formatInteger(report.tokenTotals.rawTotalTokens)} total`, "█", "raw", options, "raw"));
-  lines.push(renderMetricRow("direct burn", report.directTokenTotals.practicalBurn, maxBurnValue, formatCompactInteger(report.directTokenTotals.practicalBurn), `${formatPercentage(report.directTokenTotals.practicalBurn / report.tokenTotals.practicalBurn)} of burn`, "▒", "burn", options, "burn"));
-  lines.push(renderMetricRow("direct raw", report.directTokenTotals.rawTotalTokens, maxRawValue, formatCompactInteger(report.directTokenTotals.rawTotalTokens), `${formatPercentage(report.directTokenTotals.rawTotalTokens / report.tokenTotals.rawTotalTokens)} of raw`, "▒", "raw", options, "raw"));
-  if (report.wakeSummary) {
-    lines.push("");
-    lines.push(...renderSectionTitle("Wake Window", options));
-    lines.push(renderMetricRow("direct awake", report.wakeSummary.directActivityMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.directActivityMs), `of ${formatDurationClock(report.wakeSummary.wakeDurationMs)} wake`, "▓", "active", options));
-    lines.push(renderMetricRow("strict awake", report.wakeSummary.strictEngagementMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.strictEngagementMs), "engaged", "█", "focus", options));
-    lines.push(renderMetricRow("agent awake", report.wakeSummary.agentOnlyMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.agentOnlyMs), "agent-only", "▒", "agent", options));
-    lines.push(renderMetricRow("awake idle", report.wakeSummary.awakeIdleMs, report.wakeSummary.wakeDurationMs, formatDurationClock(report.wakeSummary.awakeIdleMs), `${formatPercentage(report.wakeSummary.awakeIdlePercentage)} idle`, "░", "idle", options));
-    lines.push(`${paint(padRight("  longest gap", 14), "muted", options)} ${paint(formatDurationClock(report.wakeSummary.longestIdleGapMs), "value", options)}  ${dim("largest quiet stretch", options)}`);
-  }
-  for (const groupBreakdown of report.groupBreakdowns) {
-    lines.push("");
-    lines.push(...renderSectionTitle(groupBreakdown.dimension === "model" ? "Model Breakdown" : "Effort Breakdown", options));
-    const maxBreakdownBurn = Math.max(...groupBreakdown.rows.map((row) => row.practicalBurn), 0);
-    for (const row of groupBreakdown.rows) {
-      lines.push(`${paint(padRight(`  ${row.key}`, 20), "muted", options)} ${paint(buildBar(row.practicalBurn, maxBreakdownBurn, 14, "█"), "burn", options)}  ${paint(padRight(formatCompactInteger(row.practicalBurn), 6), "value", options)} ${dim("burn", options)}  ${paint(padRight(formatDurationCompact(row.directActivityMs), 5), "active", options)} ${dim("direct", options)}  ${paint(padRight(formatDurationCompact(row.agentCoverageMs), 5), "agent", options)} ${dim("live", options)}  ${paint(`${row.sessionCount} s`, "value", options)}`);
+    if (currentTotal > bestValue) {
+      bestValue = currentTotal;
+      bestTimestampMs = rightPoint.timestamp.getTime();
     }
   }
-  return lines.join(`
-`);
-}
-function renderShareSummaryReport(report, options, hourlyReport, bestPlaque = null) {
-  const lines = [];
-  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, bestPlaque));
-  lines.push("");
-  lines.push(...panelLines);
-  if (hourlyReport) {
-    lines.push("");
-    lines.push(...buildRhythmSection(hourlyReport, options));
+  if (bestValue === 0) {
+    return null;
   }
-  lines.push("");
-  lines.push(...renderSectionTitle("Snapshot", options));
-  lines.push(renderSnapshotRow("focus", formatDurationHours(report.metrics.strictEngagementMs), "focused time", "focus", options));
-  lines.push(renderSnapshotRow("active", formatDurationHours(report.metrics.directActivityMs), "direct-session movement", "active", options));
-  lines.push(renderSnapshotRow(report.wakeSummary ? "idle" : "quiet", report.wakeSummary ? formatDurationClock(report.wakeSummary.awakeIdleMs) : hourlyReport ? formatDurationCompact(hourlyReport.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs), 0)) : "n/a", report.wakeSummary ? "awake idle" : "quiet hours", "idle", options));
-  lines.push(renderSnapshotRow("burn", formatCompactInteger(report.tokenTotals.practicalBurn), `${formatPercentage(report.tokenTotals.practicalBurn / report.tokenTotals.rawTotalTokens)} of raw`, "burn", options));
-  lines.push(renderSnapshotRow("agents", `${report.metrics.peakConcurrentAgents} peak`, `${formatDurationHours(report.metrics.cumulativeAgentMs)} cumulative`, "agent", options));
-  lines.push(renderSnapshotRow("sessions", `${report.sessionCounts.total}`, `${report.sessionCounts.direct} direct / ${report.sessionCounts.subagent} subagent`, "value", options));
-  return lines.join(`
-`);
+  return createRollingRecord(bestValue, bestTimestampMs);
 }
-function formatAppliedFilters(report) {
-  const appliedFilters = [];
-  if (report.appliedFilters.workspaceOnlyPrefix) {
-    appliedFilters.push(`workspace=${shortenPath(report.appliedFilters.workspaceOnlyPrefix, 48)}`);
-  }
-  if (report.appliedFilters.sessionKind) {
-    appliedFilters.push(`kind=${report.appliedFilters.sessionKind}`);
+function findBestRollingWindowOverlap(intervals) {
+  const slopeChanges = intervals.flatMap(buildSlopeChanges);
+  if (slopeChanges.length === 0) {
+    return null;
   }
-  if (report.appliedFilters.model) {
-    appliedFilters.push(`model=${report.appliedFilters.model}`);
+  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 (report.appliedFilters.reasoningEffort) {
-    appliedFilters.push(`effort=${report.appliedFilters.reasoningEffort}`);
+  if (bestValue === 0) {
+    return null;
   }
-  return appliedFilters;
+  return createRollingRecord(bestValue, bestTimestampMs);
 }
-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}`)
-    ];
+function buildSlopeChanges(interval) {
+  const startMs = interval.start.getTime();
+  const endMs = interval.end.getTime();
+  if (endMs <= startMs) {
+    return [];
   }
   return [
-    buildPostureLine(report, hourlyReport),
-    buildBiggestStoryLine(report, hourlyReport),
-    buildSupportFactsLine(report),
-    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
+    { timestampMs: startMs, deltaSlope: 1 },
+    { timestampMs: endMs, deltaSlope: -1 },
+    { timestampMs: startMs + rollingWindowDurationMs, deltaSlope: -1 },
+    { timestampMs: endMs + rollingWindowDurationMs, deltaSlope: 1 }
   ];
 }
-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 createRollingRecord(value, observedAtMs) {
+  return {
+    value,
+    observedAt: new Date(observedAtMs),
+    windowStart: new Date(observedAtMs - rollingWindowDurationMs),
+    windowEnd: new Date(observedAtMs)
+  };
 }
-function findLongestQuietRun(hourlyReport) {
-  let longestQuietRun = {
-    durationMs: 0,
-    start: hourlyReport.buckets[0]?.start ?? new Date(0)
+
+// 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))
   };
-  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;
+}
+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 (currentStart && currentDurationMs > longestQuietRun.durationMs) {
-      longestQuietRun = {
-        durationMs: currentDurationMs,
-        start: currentStart
+    if (!bestRecord || activeCount > bestRecord.value) {
+      bestRecord = {
+        value: activeCount,
+        observedAt: new Date(timestampMs),
+        windowStart: new Date(timestampMs),
+        windowEnd: new Date(nextTimestampMs)
       };
     }
-    currentStart = null;
-    currentDurationMs = 0;
   }
-  if (currentStart && currentDurationMs > longestQuietRun.durationMs) {
-    longestQuietRun = {
-      durationMs: currentDurationMs,
-      start: currentStart
-    };
+  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);
+      }
+    }
   }
-  if (longestQuietRun.durationMs > 0) {
-    return longestQuietRun;
+  return sessionFiles.sort();
+}
+async function readDirectoryEntries2(directoryPath) {
+  try {
+    return await readdir2(directoryPath, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingDirectoryError2(error)) {
+      return [];
+    }
+    throw error;
   }
-  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";
+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"
+    };
   }
-  if (hourOfDay < 12) {
-    return "this morning";
+  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 (hourOfDay < 17) {
-    return "this afternoon";
+  if (!currentRecord || candidateRecord.value > currentRecord.value) {
+    return candidateRecord;
   }
-  return "this evening";
-}
-function formatDurationLabel(durationMs) {
-  return `${Math.round(durationMs / 60000)}m`;
+  return currentRecord;
 }
-function renderMetricRow(label, value, maxValue, primaryText, detailText, filledCharacter, role, options, valueRole = "value") {
-  return `${paint(padRight(`  ${label}`, 14), "muted", options)} ${paint(buildBar(value, maxValue, summaryBarWidth, filledCharacter), role, options)}  ${paint(padRight(primaryText, 7), valueRole, options)} ${dim(detailText, options)}`;
+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 renderSnapshotRow(label, primaryText, detailText, role, options) {
-  return `${paint(padRight(`  ${label}`, 12), role, options)} ${paint(padRight(primaryText, 10), "value", options)} ${dim(detailText, options)}`;
+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-last24h-command.ts
-async function runLast24hCommand(command) {
-  const window = resolveTrailingReportWindow({ durationMs: command.hourlyWindowMs });
-  const bestMetrics = await refreshBestMetrics();
-  await notifyBestEvents(bestMetrics.newBestEvents);
-  await notifyNearBestMetrics(bestMetrics.currentMetrics, bestMetrics.ledger);
-  const sessions = await readCodexSessions({
-    windowStart: window.start,
-    windowEnd: window.end
-  });
-  const summaryReport = buildSummaryReport(sessions, {
-    filters: command.filters,
-    groupBy: command.groupBy,
-    idleCutoffMs: command.idleCutoffMs,
-    wakeWindow: command.wakeWindow,
-    window
-  });
-  const hourlyReport = buildHourlyReport(sessions, {
-    filters: command.filters,
-    idleCutoffMs: command.idleCutoffMs,
-    wakeWindow: command.wakeWindow,
-    window
-  });
-  return renderSummaryReport(summaryReport, createRenderOptions(command.shareMode), hourlyReport, buildBestPlaque(bestMetrics.ledger));
+// 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 runTodayCommand(command) {
-  const window = resolveTodayReportWindow();
-  const bestMetrics = await refreshBestMetrics();
-  await notifyBestEvents(bestMetrics.newBestEvents);
-  await notifyNearBestMetrics(bestMetrics.currentMetrics, bestMetrics.ledger);
-  const sessions = await readCodexSessions({
+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
+    windowEnd: window.end,
+    sessionRootDirectory: options.sessionRootDirectory
   });
-  return renderSummaryReport(buildSummaryReport(sessions, {
-    filters: command.filters,
-    groupBy: command.groupBy,
-    idleCutoffMs: command.idleCutoffMs,
-    wakeWindow: command.wakeWindow,
-    window
-  }), createRenderOptions(command.shareMode), undefined, buildBestPlaque(bestMetrics.ledger));
+  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
@@ -2400,9 +3279,86 @@ async function runIdletimeCli(argv) {
     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));