idletime 0.1.0

package/dist/idletime.js

@@ -0,0 +1,1503 @@
+#!/usr/bin/env node
+// package.json
+var package_default = {
+  name: "idletime",
+  version: "0.1.0",
+  description: "Visual CLI for Codex focus, token burn, spikes, and idle time from local session logs.",
+  author: "ParkerRex",
+  main: "./dist/idletime.js",
+  module: "dist/idletime.js",
+  bin: {
+    idletime: "dist/idletime.js"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ParkerRex/idletime.git"
+  },
+  homepage: "https://github.com/ParkerRex/idletime#readme",
+  bugs: {
+    url: "https://github.com/ParkerRex/idletime/issues"
+  },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  files: [
+    "dist",
+    "assets",
+    "README.md"
+  ],
+  engines: {
+    node: ">=20",
+    bun: ">=1.3.0"
+  },
+  keywords: [
+    "cli",
+    "codex",
+    "developer-tools",
+    "productivity",
+    "terminal",
+    "tokens"
+  ],
+  license: "UNLICENSED",
+  packageManager: "bun@1.3.5",
+  preferGlobal: true,
+  type: "module",
+  sideEffects: false,
+  scripts: {
+    build: "bun run src/release/build-package.ts",
+    "check:release": "bun run typecheck && bun test && bun run build && npm pack --dry-run",
+    dev: "bun run src/cli/idletime-bin.ts",
+    idletime: "bun run src/cli/idletime-bin.ts",
+    "pack:dry-run": "npm pack --dry-run",
+    "publish:dry-run": "bun run build && bun publish --dry-run --access public",
+    prepublishOnly: "bun run check:release",
+    test: "bun test",
+    typecheck: "tsc --noEmit"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/report-window/parse-duration.ts
+var durationPattern = /^(\d+)(m|h|d)$/;
+function parseDurationToMs(durationText) {
+  const match = durationPattern.exec(durationText.trim());
+  if (!match) {
+    throw new Error(`Unsupported duration "${durationText}". Use 15m, 24h, or 2d.`);
+  }
+  const value = Number(match[1]);
+  const unit = match[2];
+  const unitMultiplier = unit === "m" ? 60000 : unit === "h" ? 3600000 : 86400000;
+  return value * unitMultiplier;
+}
+
+// src/report-window/time-zone.ts
+var formatterCache = new Map;
+function getZonedDateParts(timestamp, timeZone) {
+  const formatter = getFormatter(timeZone);
+  const parts = formatter.formatToParts(timestamp);
+  return {
+    year: readPart(parts, "year"),
+    month: readPart(parts, "month"),
+    day: readPart(parts, "day"),
+    hour: readPart(parts, "hour"),
+    minute: readPart(parts, "minute"),
+    second: readPart(parts, "second")
+  };
+}
+function createUtcDateFromZonedParts(parts, timeZone) {
+  let candidate = new Date(Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second));
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    const actualParts = getZonedDateParts(candidate, timeZone);
+    const desiredTimestampMs = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    const actualTimestampMs = Date.UTC(actualParts.year, actualParts.month - 1, actualParts.day, actualParts.hour, actualParts.minute, actualParts.second);
+    const adjustmentMs = desiredTimestampMs - actualTimestampMs;
+    if (adjustmentMs === 0) {
+      return candidate;
+    }
+    candidate = new Date(candidate.getTime() + adjustmentMs);
+  }
+  return candidate;
+}
+function getFormatter(timeZone) {
+  const cachedFormatter = formatterCache.get(timeZone);
+  if (cachedFormatter) {
+    return cachedFormatter;
+  }
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  formatterCache.set(timeZone, formatter);
+  return formatter;
+}
+function readPart(parts, type) {
+  const part = parts.find((entry) => entry.type === type);
+  if (!part) {
+    throw new Error(`Missing ${type} part while formatting zoned date.`);
+  }
+  return Number(part.value);
+}
+
+// src/reporting/time-interval.ts
+function mergeTimeIntervals(intervals) {
+  if (intervals.length === 0) {
+    return [];
+  }
+  const sortedIntervals = [...intervals].sort((leftInterval, rightInterval) => leftInterval.start.getTime() - rightInterval.start.getTime());
+  const mergedIntervals = [copyInterval(sortedIntervals[0])];
+  for (const interval of sortedIntervals.slice(1)) {
+    const currentInterval = mergedIntervals[mergedIntervals.length - 1];
+    if (interval.start.getTime() <= currentInterval.end.getTime()) {
+      currentInterval.end = new Date(Math.max(currentInterval.end.getTime(), interval.end.getTime()));
+      continue;
+    }
+    mergedIntervals.push(copyInterval(interval));
+  }
+  return mergedIntervals;
+}
+function intersectTimeIntervals(leftIntervals, rightIntervals) {
+  const intersections = [];
+  for (const leftInterval of leftIntervals) {
+    for (const rightInterval of rightIntervals) {
+      const start = new Date(Math.max(leftInterval.start.getTime(), rightInterval.start.getTime()));
+      const end = new Date(Math.min(leftInterval.end.getTime(), rightInterval.end.getTime()));
+      if (start.getTime() < end.getTime()) {
+        intersections.push({ start, end });
+      }
+    }
+  }
+  return mergeTimeIntervals(intersections);
+}
+function subtractTimeIntervals(baseIntervals, intervalsToRemove) {
+  const mergedRemovals = mergeTimeIntervals(intervalsToRemove);
+  let remainingIntervals = mergeTimeIntervals(baseIntervals);
+  for (const removal of mergedRemovals) {
+    const nextRemainingIntervals = [];
+    for (const interval of remainingIntervals) {
+      if (removal.end.getTime() <= interval.start.getTime() || removal.start.getTime() >= interval.end.getTime()) {
+        nextRemainingIntervals.push(interval);
+        continue;
+      }
+      if (removal.start.getTime() > interval.start.getTime()) {
+        nextRemainingIntervals.push({
+          start: interval.start,
+          end: new Date(removal.start)
+        });
+      }
+      if (removal.end.getTime() < interval.end.getTime()) {
+        nextRemainingIntervals.push({
+          start: new Date(removal.end),
+          end: interval.end
+        });
+      }
+    }
+    remainingIntervals = nextRemainingIntervals;
+  }
+  return remainingIntervals;
+}
+function sumTimeIntervalsMs(intervals) {
+  return intervals.reduce((totalDurationMs, interval) => totalDurationMs + (interval.end.getTime() - interval.start.getTime()), 0);
+}
+function measureOverlapMs(intervals, targetInterval) {
+  return sumTimeIntervalsMs(intersectTimeIntervals(intervals, [targetInterval]));
+}
+function peakConcurrency(intervalGroups) {
+  const edges = [];
+  for (const intervalGroup of intervalGroups) {
+    for (const interval of intervalGroup) {
+      edges.push({ timestampMs: interval.start.getTime(), delta: 1 });
+      edges.push({ timestampMs: interval.end.getTime(), delta: -1 });
+    }
+  }
+  edges.sort((leftEdge, rightEdge) => leftEdge.timestampMs - rightEdge.timestampMs || leftEdge.delta - rightEdge.delta);
+  let activeCount = 0;
+  let peakActiveCount = 0;
+  for (const edge of edges) {
+    activeCount += edge.delta;
+    peakActiveCount = Math.max(peakActiveCount, activeCount);
+  }
+  return peakActiveCount;
+}
+function copyInterval(interval) {
+  return {
+    start: new Date(interval.start),
+    end: new Date(interval.end)
+  };
+}
+
+// src/reporting/wake-window.ts
+function parseWakeWindow(wakeWindowText) {
+  const match = /^(\d{2}):(\d{2})-(\d{2}):(\d{2})$/.exec(wakeWindowText.trim());
+  if (!match) {
+    throw new Error(`Unsupported wake window "${wakeWindowText}". Use HH:MM-HH:MM.`);
+  }
+  const startMinutes = Number(match[1]) * 60 + Number(match[2]);
+  const endMinutes = Number(match[3]) * 60 + Number(match[4]);
+  if (startMinutes > 24 * 60 || endMinutes > 24 * 60) {
+    throw new Error("Wake window minutes must stay within the day.");
+  }
+  return {
+    label: wakeWindowText,
+    startMinutes,
+    endMinutes
+  };
+}
+function summarizeWakeWindow(wakeWindow, reportWindow, activityMetrics) {
+  const wakeIntervals = buildWakeIntervalsForReportWindow(wakeWindow, reportWindow);
+  const strictIntervals = intersectTimeIntervals(activityMetrics.strictEngagementBlocks, wakeIntervals);
+  const directIntervals = intersectTimeIntervals(activityMetrics.directActivityBlocks, wakeIntervals);
+  const agentOnlyIntervals = intersectTimeIntervals(activityMetrics.agentOnlyBlocks, wakeIntervals);
+  const awakeBusyIntervals = mergeTimeIntervals([
+    ...directIntervals,
+    ...agentOnlyIntervals
+  ]);
+  const awakeIdleIntervals = subtractTimeIntervals(wakeIntervals, awakeBusyIntervals);
+  const wakeDurationMs = sumTimeIntervalsMs(wakeIntervals);
+  const awakeIdleMs = sumTimeIntervalsMs(awakeIdleIntervals);
+  return {
+    wakeDurationMs,
+    strictEngagementMs: sumTimeIntervalsMs(strictIntervals),
+    directActivityMs: sumTimeIntervalsMs(directIntervals),
+    agentOnlyMs: sumTimeIntervalsMs(agentOnlyIntervals),
+    awakeIdleMs,
+    awakeIdlePercentage: wakeDurationMs === 0 ? 0 : awakeIdleMs / wakeDurationMs,
+    longestIdleGapMs: awakeIdleIntervals.reduce((longestGapMs, interval) => Math.max(longestGapMs, interval.end.getTime() - interval.start.getTime()), 0)
+  };
+}
+function buildWakeIntervalsForReportWindow(wakeWindow, reportWindow) {
+  const intervals = [];
+  const firstDayParts = getZonedDateParts(reportWindow.start, reportWindow.timeZone);
+  const lastDayParts = getZonedDateParts(reportWindow.end, reportWindow.timeZone);
+  const firstDay = new Date(Date.UTC(firstDayParts.year, firstDayParts.month - 1, firstDayParts.day));
+  const lastDay = new Date(Date.UTC(lastDayParts.year, lastDayParts.month - 1, lastDayParts.day));
+  for (const day = new Date(firstDay);day.getTime() <= lastDay.getTime(); day.setUTCDate(day.getUTCDate() + 1)) {
+    const start = createUtcDateFromZonedParts({
+      year: day.getUTCFullYear(),
+      month: day.getUTCMonth() + 1,
+      day: day.getUTCDate(),
+      hour: Math.floor(wakeWindow.startMinutes / 60),
+      minute: wakeWindow.startMinutes % 60,
+      second: 0
+    }, reportWindow.timeZone);
+    const endDay = new Date(day);
+    if (wakeWindow.endMinutes <= wakeWindow.startMinutes) {
+      endDay.setUTCDate(endDay.getUTCDate() + 1);
+    }
+    const end = createUtcDateFromZonedParts({
+      year: endDay.getUTCFullYear(),
+      month: endDay.getUTCMonth() + 1,
+      day: endDay.getUTCDate(),
+      hour: Math.floor(wakeWindow.endMinutes / 60),
+      minute: wakeWindow.endMinutes % 60,
+      second: 0
+    }, reportWindow.timeZone);
+    const clippedStart = new Date(Math.max(start.getTime(), reportWindow.start.getTime()));
+    const clippedEnd = new Date(Math.min(end.getTime(), reportWindow.end.getTime()));
+    if (clippedStart.getTime() < clippedEnd.getTime()) {
+      intervals.push({ start: clippedStart, end: clippedEnd });
+    }
+  }
+  return intervals;
+}
+
+// src/cli/parse-idletime-command.ts
+var defaultIdleCutoffMs = parseDurationToMs("15m");
+var defaultWindowMs = parseDurationToMs("24h");
+function parseIdletimeCommand(argv) {
+  const args = [...argv];
+  const firstArgument = args[0];
+  const commandName = isCommandName(firstArgument) ? firstArgument : "last24h";
+  if (isCommandName(firstArgument)) {
+    args.shift();
+  }
+  const filters = {
+    workspaceOnlyPrefix: null,
+    sessionKind: null,
+    model: null,
+    reasoningEffort: null
+  };
+  const groupBy = [];
+  let helpRequested = false;
+  let hourlyWindowMs = defaultWindowMs;
+  let idleCutoffMs = defaultIdleCutoffMs;
+  let shareMode = false;
+  let versionRequested = false;
+  let wakeWindow = null;
+  while (args.length > 0) {
+    const argument = args.shift();
+    if (!argument) {
+      break;
+    }
+    if (argument === "--help" || argument === "-h" || argument === "help") {
+      helpRequested = true;
+      continue;
+    }
+    if (argument === "--version" || argument === "-v") {
+      versionRequested = true;
+      continue;
+    }
+    if (argument === "--window") {
+      hourlyWindowMs = parseDurationToMs(readFlagValue(argument, args));
+      continue;
+    }
+    if (argument === "--idle-cutoff") {
+      idleCutoffMs = parseDurationToMs(readFlagValue(argument, args));
+      continue;
+    }
+    if (argument === "--workspace-only") {
+      filters.workspaceOnlyPrefix = readFlagValue(argument, args);
+      continue;
+    }
+    if (argument === "--session-kind") {
+      filters.sessionKind = parseSessionKind(readFlagValue(argument, args));
+      continue;
+    }
+    if (argument === "--model") {
+      filters.model = readFlagValue(argument, args);
+      continue;
+    }
+    if (argument === "--effort") {
+      filters.reasoningEffort = readFlagValue(argument, args);
+      continue;
+    }
+    if (argument === "--wake") {
+      wakeWindow = parseWakeWindow(readFlagValue(argument, args));
+      continue;
+    }
+    if (argument === "--share") {
+      shareMode = true;
+      continue;
+    }
+    if (argument === "--group-by") {
+      const dimension = readFlagValue(argument, args);
+      if (dimension !== "model" && dimension !== "effort") {
+        throw new Error(`Unsupported group-by dimension "${dimension}".`);
+      }
+      if (!groupBy.includes(dimension)) {
+        groupBy.push(dimension);
+      }
+      continue;
+    }
+    throw new Error(`Unknown argument "${argument}".`);
+  }
+  return {
+    commandName,
+    filters,
+    groupBy,
+    helpRequested,
+    hourlyWindowMs,
+    idleCutoffMs,
+    shareMode,
+    versionRequested,
+    wakeWindow
+  };
+}
+function renderHelpText() {
+  return [
+    "idletime",
+    "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]",
+    "",
+    "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",
+    "",
+    "How To Read The Dashboard:",
+    "  focus     strict engagement inferred from actual user_message arrivals",
+    "  active    broader direct-session activity in the main thread",
+    "  idle      awake idle time when you pass --wake",
+    "  quiet     non-active time when no wake window is supplied",
+    "  burn      practical burn = input - cached_input + output",
+    "",
+    "Options:",
+    "  --window <24h>          trailing window for hourly or last24h",
+    "  --idle-cutoff <15m>     how long activity stays live after the last event",
+    "  --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",
+    "  --effort <level>        include only one primary reasoning effort",
+    "  --wake <HH:MM-HH:MM>    turn quiet time into real awake idle time",
+    "  --group-by <dimension>  model or effort; repeatable for summaries",
+    "  --share                 trim the output into a screenshot card",
+    "  --version               print the CLI version",
+    "",
+    "Examples:",
+    "  idletime",
+    "  idletime --wake 07:45-23:30",
+    "  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 --version"
+  ].join(`
+`);
+}
+function isCommandName(value) {
+  return value === "hourly" || value === "last24h" || value === "today";
+}
+function parseSessionKind(sessionKindText) {
+  if (sessionKindText === "direct" || sessionKindText === "subagent") {
+    return sessionKindText;
+  }
+  throw new Error(`Unsupported session kind "${sessionKindText}".`);
+}
+function readFlagValue(flagName, args) {
+  const value = args.shift();
+  if (!value) {
+    throw new Error(`${flagName} requires a value.`);
+  }
+  return value;
+}
+
+// src/codex-session-log/read-codex-sessions.ts
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// src/codex-session-log/parse-codex-session.ts
+import { readFile } from "node:fs/promises";
+
+// src/codex-session-log/codex-log-values.ts
+function expectObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  return value;
+}
+function readString(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${label}.${key} must be a non-empty string.`);
+  }
+  return value;
+}
+function readOptionalString(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readNumber(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new Error(`${label}.${key} must be a number.`);
+  }
+  return value;
+}
+function readIsoTimestamp(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be an ISO timestamp string.`);
+  }
+  const timestamp = new Date(value);
+  if (Number.isNaN(timestamp.getTime())) {
+    throw new Error(`${label} is not a valid ISO timestamp.`);
+  }
+  return timestamp;
+}
+
+// src/codex-session-log/classify-session-kind.ts
+function classifySessionKind(sourceValue) {
+  if (sourceValue === undefined || sourceValue === "cli" || sourceValue === "exec" || sourceValue === "vscode") {
+    return "direct";
+  }
+  const sourceRecord = expectObject(sourceValue, "session_meta.payload.source");
+  if ("subagent" in sourceRecord) {
+    return "subagent";
+  }
+  if ("custom" in sourceRecord) {
+    return "direct";
+  }
+  throw new Error("Unsupported session source payload.");
+}
+
+// src/codex-session-log/codex-log-line.ts
+function parseCodexLogLine(lineText, sourceFilePath, lineNumber) {
+  let parsedValue;
+  try {
+    parsedValue = JSON.parse(lineText);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON in ${sourceFilePath}:${lineNumber}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const record = expectObject(parsedValue, `${sourceFilePath}:${lineNumber}`);
+  return {
+    timestamp: readIsoTimestamp(record.timestamp, `${sourceFilePath}:${lineNumber}.timestamp`),
+    type: readString(record, "type", `${sourceFilePath}:${lineNumber}`),
+    payload: record.payload
+  };
+}
+
+// src/codex-session-log/token-usage.ts
+function readTokenUsage(value, label) {
+  const record = expectObject(value, label);
+  const inputTokens = readNumber(record, "input_tokens", label);
+  const cachedInputTokens = readNumber(record, "cached_input_tokens", label);
+  const outputTokens = readNumber(record, "output_tokens", label);
+  const reasoningOutputTokens = readNumber(record, "reasoning_output_tokens", label);
+  const totalTokens = readNumber(record, "total_tokens", label);
+  return {
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    reasoningOutputTokens,
+    totalTokens,
+    practicalBurn: inputTokens - cachedInputTokens + outputTokens
+  };
+}
+function subtractTokenUsages(currentUsage, previousUsage) {
+  const nextUsage = {
+    inputTokens: currentUsage.inputTokens - previousUsage.inputTokens,
+    cachedInputTokens: currentUsage.cachedInputTokens - previousUsage.cachedInputTokens,
+    outputTokens: currentUsage.outputTokens - previousUsage.outputTokens,
+    reasoningOutputTokens: currentUsage.reasoningOutputTokens - previousUsage.reasoningOutputTokens,
+    totalTokens: currentUsage.totalTokens - previousUsage.totalTokens,
+    practicalBurn: currentUsage.practicalBurn - previousUsage.practicalBurn
+  };
+  for (const [key, value] of Object.entries(nextUsage)) {
+    if (value < 0) {
+      throw new Error(`Token usage regressed for ${key}.`);
+    }
+  }
+  return nextUsage;
+}
+
+// src/codex-session-log/extract-token-points.ts
+function extractTokenPoints(records) {
+  const tokenPoints = [];
+  for (const record of records) {
+    if (record.type !== "event_msg") {
+      continue;
+    }
+    const payload = expectObject(record.payload, "event_msg.payload");
+    if (readOptionalString(payload, "type") !== "token_count") {
+      continue;
+    }
+    const info = payload.info;
+    if (info === null || info === undefined) {
+      continue;
+    }
+    const infoRecord = expectObject(info, "event_msg.payload.info");
+    tokenPoints.push({
+      timestamp: record.timestamp,
+      usage: readTokenUsage(infoRecord.total_token_usage, "event_msg.payload.info.total_token_usage")
+    });
+  }
+  return tokenPoints.sort((leftPoint, rightPoint) => leftPoint.timestamp.getTime() - rightPoint.timestamp.getTime());
+}
+function buildTokenDeltaPoints(tokenPoints) {
+  const deltaPoints = [];
+  let previousPoint = null;
+  for (const tokenPoint of tokenPoints) {
+    deltaPoints.push({
+      timestamp: tokenPoint.timestamp,
+      cumulativeUsage: tokenPoint.usage,
+      deltaUsage: previousPoint ? subtractTokenUsages(tokenPoint.usage, previousPoint.usage) : tokenPoint.usage
+    });
+    previousPoint = tokenPoint;
+  }
+  return deltaPoints;
+}
+
+// src/codex-session-log/extract-turn-attribution.ts
+function extractTurnAttribution(records) {
+  const agentSpawnRequests = [];
+  const turnAttributions = [];
+  for (const record of records) {
+    if (record.type === "turn_context") {
+      const payload2 = expectObject(record.payload, "turn_context.payload");
+      turnAttributions.push({
+        turnId: readString(payload2, "turn_id", "turn_context.payload"),
+        timestamp: record.timestamp,
+        cwd: readString(payload2, "cwd", "turn_context.payload"),
+        model: readOptionalString(payload2, "model"),
+        reasoningEffort: readOptionalString(payload2, "effort")
+      });
+      continue;
+    }
+    if (record.type !== "response_item") {
+      continue;
+    }
+    const payload = expectObject(record.payload, "response_item.payload");
+    if (readOptionalString(payload, "type") !== "function_call" || readOptionalString(payload, "name") !== "spawn_agent") {
+      continue;
+    }
+    const argumentsText = readString(payload, "arguments", "response_item.payload");
+    let parsedArguments;
+    try {
+      parsedArguments = JSON.parse(argumentsText);
+    } catch (error) {
+      throw new Error(`spawn_agent arguments are not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const argumentsRecord = expectObject(parsedArguments, "spawn_agent.arguments");
+    agentSpawnRequests.push({
+      timestamp: record.timestamp,
+      agentType: readOptionalString(argumentsRecord, "agent_type"),
+      model: readOptionalString(argumentsRecord, "model"),
+      reasoningEffort: readOptionalString(argumentsRecord, "reasoning_effort")
+    });
+  }
+  return {
+    agentSpawnRequests,
+    turnAttributions
+  };
+}
+function resolvePrimaryModel(turnAttributions) {
+  for (let index = turnAttributions.length - 1;index >= 0; index -= 1) {
+    const model = turnAttributions[index]?.model;
+    if (model) {
+      return model;
+    }
+  }
+  return null;
+}
+function resolvePrimaryReasoningEffort(turnAttributions) {
+  for (let index = turnAttributions.length - 1;index >= 0; index -= 1) {
+    const reasoningEffort = turnAttributions[index]?.reasoningEffort;
+    if (reasoningEffort) {
+      return reasoningEffort;
+    }
+  }
+  return null;
+}
+
+// src/codex-session-log/extract-user-message-timestamps.ts
+function extractUserMessageTimestamps(records) {
+  const timestamps = [];
+  for (const record of records) {
+    if (record.type !== "event_msg") {
+      continue;
+    }
+    const payload = expectObject(record.payload, "event_msg.payload");
+    if (readOptionalString(payload, "type") === "user_message") {
+      timestamps.push(record.timestamp);
+    }
+  }
+  return timestamps;
+}
+
+// src/codex-session-log/parse-codex-session.ts
+async function parseCodexSession(sourceFilePath) {
+  const rawFileText = await readFile(sourceFilePath, "utf8");
+  const lineTexts = rawFileText.split(`
+`).map((lineText) => lineText.trim()).filter((lineText) => lineText.length > 0);
+  if (lineTexts.length === 0) {
+    throw new Error(`${sourceFilePath} is empty.`);
+  }
+  const records = lineTexts.map((lineText, index) => parseCodexLogLine(lineText, sourceFilePath, index + 1));
+  const sessionMetaRecord = records[0];
+  if (!sessionMetaRecord || sessionMetaRecord.type !== "session_meta") {
+    throw new Error(`${sourceFilePath} must start with a session_meta record.`);
+  }
+  const sessionMetaPayload = expectObject(sessionMetaRecord.payload, "session_meta.payload");
+  const firstRecord = records[0];
+  const lastRecord = records[records.length - 1];
+  const tokenPoints = extractTokenPoints(records);
+  const userMessageTimestamps = extractUserMessageTimestamps(records);
+  const { turnAttributions, agentSpawnRequests } = extractTurnAttribution(records);
+  const eventTimestamps = records.filter((record) => record.type !== "session_meta").map((record) => record.timestamp);
+  return {
+    sessionId: readString(sessionMetaPayload, "id", "session_meta.payload"),
+    sourceFilePath,
+    cwd: readString(sessionMetaPayload, "cwd", "session_meta.payload"),
+    kind: classifySessionKind(sessionMetaPayload.source),
+    forkedFromSessionId: readOptionalString(sessionMetaPayload, "forked_from_id"),
+    firstTimestamp: firstRecord.timestamp,
+    lastTimestamp: lastRecord.timestamp,
+    eventTimestamps: eventTimestamps.length > 0 ? eventTimestamps : [firstRecord.timestamp],
+    tokenPoints,
+    finalTokenUsage: tokenPoints.length > 0 ? tokenPoints[tokenPoints.length - 1]?.usage ?? null : null,
+    userMessageTimestamps,
+    turnAttributions,
+    agentSpawnRequests,
+    primaryModel: resolvePrimaryModel(turnAttributions),
+    primaryReasoningEffort: resolvePrimaryReasoningEffort(turnAttributions)
+  };
+}
+
+// src/codex-session-log/read-codex-sessions.ts
+var defaultSessionRootDirectory = join(homedir(), ".codex", "sessions");
+async function readCodexSessions(options) {
+  if (options.windowEnd.getTime() < options.windowStart.getTime()) {
+    throw new Error("windowEnd must be later than windowStart.");
+  }
+  const sessionRootDirectory = options.sessionRootDirectory ?? defaultSessionRootDirectory;
+  const candidateFiles = await listCandidateSessionFiles(sessionRootDirectory, options.windowStart, options.windowEnd);
+  const parsedSessions = await Promise.all(candidateFiles.map((candidateFile) => parseCodexSession(candidateFile)));
+  return parsedSessions.filter((parsedSession) => parsedSession.lastTimestamp.getTime() >= options.windowStart.getTime() && parsedSession.firstTimestamp.getTime() <= options.windowEnd.getTime()).sort((leftSession, rightSession) => leftSession.firstTimestamp.getTime() - rightSession.firstTimestamp.getTime());
+}
+async function listCandidateSessionFiles(sessionRootDirectory, windowStart, windowEnd) {
+  const candidateDirectories = buildCandidateDirectories(sessionRootDirectory, windowStart, windowEnd);
+  const candidateFiles = [];
+  for (const candidateDirectory of candidateDirectories) {
+    const directoryEntries = await readDirectoryEntries(candidateDirectory);
+    for (const directoryEntry of directoryEntries) {
+      if (directoryEntry.isFile() && directoryEntry.name.endsWith(".jsonl")) {
+        candidateFiles.push(join(candidateDirectory, directoryEntry.name));
+      }
+    }
+  }
+  return candidateFiles.sort();
+}
+function buildCandidateDirectories(sessionRootDirectory, windowStart, windowEnd) {
+  const firstDirectoryDate = startOfLocalDay(new Date(windowStart.getTime() - 24 * 60 * 60 * 1000));
+  const lastDirectoryDate = startOfLocalDay(windowEnd);
+  const directories = [];
+  for (const currentDate = new Date(firstDirectoryDate);currentDate.getTime() <= lastDirectoryDate.getTime(); currentDate.setDate(currentDate.getDate() + 1)) {
+    directories.push(join(sessionRootDirectory, currentDate.getFullYear().toString().padStart(4, "0"), `${currentDate.getMonth() + 1}`.padStart(2, "0"), `${currentDate.getDate()}`.padStart(2, "0")));
+  }
+  return directories;
+}
+async function readDirectoryEntries(directoryPath) {
+  try {
+    return await readdir(directoryPath, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingDirectoryError(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function isMissingDirectoryError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function startOfLocalDay(timestamp) {
+  return new Date(timestamp.getFullYear(), timestamp.getMonth(), timestamp.getDate(), 0, 0, 0, 0);
+}
+
+// src/report-window/resolve-report-window.ts
+function resolveTrailingReportWindow(options = {}) {
+  const now = options.now ?? new Date;
+  const durationMs = options.durationMs ?? 24 * 60 * 60 * 1000;
+  return {
+    label: `last${Math.round(durationMs / 3600000)}h`,
+    start: new Date(now.getTime() - durationMs),
+    end: now,
+    timeZone: options.timeZone ?? getLocalTimeZone()
+  };
+}
+function resolveTodayReportWindow(options = {}) {
+  const now = options.now ?? new Date;
+  return {
+    label: "today",
+    start: new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0),
+    end: now,
+    timeZone: options.timeZone ?? getLocalTimeZone()
+  };
+}
+function getLocalTimeZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+
+// src/reporting/build-activity-blocks.ts
+function buildActivityBlocks(timestamps, idleCutoffMs) {
+  if (timestamps.length === 0) {
+    return [];
+  }
+  const intervals = timestamps.slice().sort((leftTimestamp, rightTimestamp) => leftTimestamp.getTime() - rightTimestamp.getTime()).map((timestamp) => ({
+    start: new Date(timestamp),
+    end: new Date(timestamp.getTime() + idleCutoffMs)
+  }));
+  return mergeTimeIntervals(intervals);
+}
+
+// src/reporting/activity-metrics.ts
+function buildActivityMetrics(sessions, idleCutoffMs) {
+  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 agentOnlyBlocks = subtractTimeIntervals(agentCoverageBlocks, directActivityBlocks);
+  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)
+  };
+}
+
+// src/reporting/filter-sessions.ts
+function filterSessions(sessions, filters) {
+  return sessions.filter((session) => {
+    if (filters.workspaceOnlyPrefix && !session.cwd.startsWith(filters.workspaceOnlyPrefix)) {
+      return false;
+    }
+    if (filters.sessionKind && session.kind !== filters.sessionKind) {
+      return false;
+    }
+    if (filters.model && session.primaryModel !== filters.model) {
+      return false;
+    }
+    if (filters.reasoningEffort && session.primaryReasoningEffort !== filters.reasoningEffort) {
+      return false;
+    }
+    return true;
+  });
+}
+function groupSessions(sessions, dimension) {
+  const groupedSessions = new Map;
+  for (const session of sessions) {
+    const key = dimension === "model" ? session.primaryModel ?? "unknown" : session.primaryReasoningEffort ?? "unknown";
+    const existingGroup = groupedSessions.get(key) ?? [];
+    existingGroup.push(session);
+    groupedSessions.set(key, existingGroup);
+  }
+  return [...groupedSessions.entries()].map(([key, groupedValues]) => ({ key, sessions: groupedValues })).sort((leftGroup, rightGroup) => rightGroup.sessions.length - leftGroup.sessions.length);
+}
+
+// src/reporting/build-hourly-report.ts
+function buildHourlyReport(sessions, query) {
+  const filteredSessions = filterSessions(sessions, query.filters);
+  const metrics = buildActivityMetrics(filteredSessions, query.idleCutoffMs);
+  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,
+    buckets,
+    hasWakeWindow: query.wakeWindow !== null,
+    idleCutoffMs: query.idleCutoffMs,
+    maxValues: {
+      agentOnlyMs: Math.max(...buckets.map((bucket) => bucket.agentOnlyMs), 0),
+      directActivityMs: Math.max(...buckets.map((bucket) => bucket.directActivityMs), 0),
+      engagedMs: Math.max(...buckets.map((bucket) => bucket.engagedMs), 0),
+      practicalBurn: Math.max(...buckets.map((bucket) => bucket.practicalBurn), 0)
+    },
+    window: query.window
+  };
+}
+function buildBuckets(windowStart, windowEnd, sessions, metrics, wakeIntervals) {
+  const buckets = [];
+  const firstBucketStart = startOfHour(windowStart);
+  for (const bucketStart = new Date(firstBucketStart);bucketStart.getTime() < windowEnd.getTime(); bucketStart.setHours(bucketStart.getHours() + 1)) {
+    const bucketEnd = new Date(Math.min(bucketStart.getTime() + 60 * 60 * 1000, windowEnd.getTime()));
+    const bucketInterval = { start: new Date(bucketStart), end: bucketEnd };
+    const directActivityMs = measureOverlapMs(metrics.directActivityBlocks, bucketInterval);
+    const agentOnlyMs = measureOverlapMs(metrics.agentOnlyBlocks, bucketInterval);
+    const awakeIdleMs = wakeIntervals ? Math.max(0, measureOverlapMs(wakeIntervals, bucketInterval) - directActivityMs - agentOnlyMs) : 0;
+    buckets.push({
+      start: new Date(bucketStart),
+      end: bucketEnd,
+      agentOnlyMs,
+      awakeIdleMs,
+      directActivityMs,
+      engagedMs: measureOverlapMs(metrics.strictEngagementBlocks, bucketInterval),
+      peakConcurrentAgents: peakConcurrency(metrics.perSubagentBlocks.map((sessionBlocks) => clipIntervals(sessionBlocks, bucketInterval))),
+      practicalBurn: sumTokenBurn(sessions, bucketInterval),
+      rawTotalTokens: sumRawTokenDeltas(sessions, bucketInterval),
+      sessionCount: countSessionsInBucket(sessions, bucketInterval)
+    });
+  }
+  return buckets;
+}
+function countSessionsInBucket(sessions, bucketInterval) {
+  return sessions.filter((session) => session.eventTimestamps.some((timestamp) => timestamp.getTime() >= bucketInterval.start.getTime() && timestamp.getTime() < bucketInterval.end.getTime())).length;
+}
+function sumTokenBurn(sessions, bucketInterval) {
+  return sessions.reduce((totalPracticalBurn, session) => {
+    const bucketBurn = buildTokenDeltaPoints(session.tokenPoints).filter((tokenDeltaPoint) => tokenDeltaPoint.timestamp.getTime() >= bucketInterval.start.getTime() && tokenDeltaPoint.timestamp.getTime() < bucketInterval.end.getTime()).reduce((bucketTotal, tokenDeltaPoint) => bucketTotal + tokenDeltaPoint.deltaUsage.practicalBurn, 0);
+    return totalPracticalBurn + bucketBurn;
+  }, 0);
+}
+function sumRawTokenDeltas(sessions, bucketInterval) {
+  return sessions.reduce((rawTokenTotal, session) => {
+    const bucketRawTokens = buildTokenDeltaPoints(session.tokenPoints).filter((tokenDeltaPoint) => tokenDeltaPoint.timestamp.getTime() >= bucketInterval.start.getTime() && tokenDeltaPoint.timestamp.getTime() < bucketInterval.end.getTime()).reduce((bucketTotal, tokenDeltaPoint) => bucketTotal + tokenDeltaPoint.deltaUsage.totalTokens, 0);
+    return rawTokenTotal + bucketRawTokens;
+  }, 0);
+}
+function clipIntervals(intervals, targetInterval) {
+  return intervals.flatMap((interval) => {
+    const clippedStart = new Date(Math.max(interval.start.getTime(), targetInterval.start.getTime()));
+    const clippedEnd = new Date(Math.min(interval.end.getTime(), targetInterval.end.getTime()));
+    if (clippedStart.getTime() >= clippedEnd.getTime()) {
+      return [];
+    }
+    return [{ start: clippedStart, end: clippedEnd }];
+  });
+}
+function startOfHour(timestamp) {
+  return new Date(timestamp.getFullYear(), timestamp.getMonth(), timestamp.getDate(), timestamp.getHours(), 0, 0, 0);
+}
+
+// src/reporting/report-formatting.ts
+var integerFormatter = new Intl.NumberFormat("en-US");
+var compactIntegerFormatter = new Intl.NumberFormat("en-US", {
+  notation: "compact",
+  maximumFractionDigits: 1
+});
+function formatDurationHours(durationMs) {
+  const hours = durationMs / 3600000;
+  return `${hours.toFixed(1)}h`;
+}
+function formatDurationClock(durationMs) {
+  const totalMinutes = Math.round(durationMs / 60000);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}h ${minutes.toString().padStart(2, "0")}m`;
+}
+function formatInteger(value) {
+  return integerFormatter.format(Math.round(value));
+}
+function formatCompactInteger(value) {
+  return compactIntegerFormatter.format(Math.round(value));
+}
+function formatPercentage(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function formatSignedDurationHours(durationMs) {
+  const sign = durationMs >= 0 ? "+" : "-";
+  return `${sign}${formatDurationHours(Math.abs(durationMs))}`;
+}
+function formatTimestamp(timestamp, reportWindow) {
+  return new Intl.DateTimeFormat("en-US", {
+    timeZone: reportWindow.timeZone,
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).format(timestamp);
+}
+function formatTimeRange(startTimestamp, endTimestamp, reportWindow) {
+  return `${formatTimestamp(startTimestamp, reportWindow)} -> ${formatTimestamp(endTimestamp, reportWindow)}`;
+}
+function buildBar(value, maxValue, width, filledCharacter = "█", emptyCharacter = "·") {
+  if (maxValue <= 0 || value <= 0) {
+    return emptyCharacter.repeat(width);
+  }
+  const filledCount = Math.max(1, Math.round(value / maxValue * width));
+  return `${filledCharacter.repeat(Math.min(width, filledCount))}${emptyCharacter.repeat(Math.max(0, width - filledCount))}`;
+}
+function buildSplitBar(segments, width, emptyCharacter = "·") {
+  const totalValue = segments.reduce((currentTotal, segment) => currentTotal + Math.max(0, segment.value), 0);
+  if (totalValue <= 0) {
+    return emptyCharacter.repeat(width);
+  }
+  let remainingWidth = width;
+  let builtBar = "";
+  for (const [index, segment] of segments.entries()) {
+    const segmentWidth = index === segments.length - 1 ? remainingWidth : Math.min(remainingWidth, Math.round(Math.max(0, segment.value) / totalValue * width));
+    builtBar += segment.filledCharacter.repeat(segmentWidth);
+    remainingWidth -= segmentWidth;
+  }
+  return `${builtBar}${emptyCharacter.repeat(Math.max(0, remainingWidth))}`;
+}
+function formatDurationCompact(durationMs) {
+  const totalMinutes = Math.round(durationMs / 60000);
+  if (totalMinutes >= 60) {
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return `${hours}h${minutes.toString().padStart(2, "0")}`;
+  }
+  return `${totalMinutes}m`;
+}
+function formatHourBucketLabel(timestamp, reportWindow) {
+  return new Intl.DateTimeFormat("en-US", {
+    timeZone: reportWindow.timeZone,
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false
+  }).format(timestamp);
+}
+function formatHourOfDay(timestamp, reportWindow) {
+  return new Intl.DateTimeFormat("en-US", {
+    timeZone: reportWindow.timeZone,
+    hour: "2-digit",
+    hour12: false
+  }).format(timestamp);
+}
+function buildSparkline(values) {
+  const levels = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  const maxValue = Math.max(...values, 0);
+  if (maxValue <= 0) {
+    return "·".repeat(values.length);
+  }
+  return values.map((value) => {
+    if (value <= 0) {
+      return "·";
+    }
+    const levelIndex = Math.max(0, Math.round(value / maxValue * (levels.length - 1)));
+    return levels[levelIndex];
+  }).join("");
+}
+function padRight(text, width) {
+  return `${text}${" ".repeat(Math.max(0, width - text.length))}`;
+}
+function shortenPath(pathText, maxLength) {
+  if (pathText.length <= maxLength) {
+    return pathText;
+  }
+  const pathSegments = pathText.split("/").filter((segment) => segment.length > 0);
+  let shortenedPath = "";
+  for (let index = pathSegments.length - 1;index >= 0; index -= 1) {
+    const nextPath = `/${pathSegments[index]}${shortenedPath}`;
+    if (nextPath.length + 4 > maxLength) {
+      break;
+    }
+    shortenedPath = nextPath;
+  }
+  return `...${shortenedPath || pathText.slice(-(maxLength - 3))}`;
+}
+
+// src/reporting/render-theme.ts
+var roleStyles = {
+  focus: "1;38;2;56;189;248",
+  active: "1;38;2;96;165;250",
+  agent: "1;38;2;168;85;247",
+  idle: "1;38;2;250;204;21",
+  burn: "1;38;2;251;146;60",
+  frame: "1;38;2;125;211;252",
+  heading: "1;38;2;248;250;252",
+  muted: "38;2;148;163;184",
+  value: "1;38;2;226;232;240"
+};
+function createRenderOptions(shareMode) {
+  return {
+    colorEnabled: Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined,
+    shareMode
+  };
+}
+function paint(text, role, options) {
+  if (!options.colorEnabled || text.length === 0) {
+    return text;
+  }
+  return `\x1B[${roleStyles[role]}m${text}\x1B[0m`;
+}
+function dim(text, options) {
+  if (!options.colorEnabled || text.length === 0) {
+    return text;
+  }
+  return `\x1B[2m${text}\x1B[0m`;
+}
+
+// src/reporting/render-layout.ts
+function buildPanel(title, lines) {
+  const innerWidth = Math.max(56, title.length + 4, ...lines.map((line) => line.length));
+  const topRuleWidth = Math.max(0, innerWidth - title.length - 2);
+  return [
+    `╭─ ${title} ${"─".repeat(topRuleWidth)}╮`,
+    ...lines.map((line) => `│ ${line}${" ".repeat(innerWidth - line.length)} │`),
+    `╰${"─".repeat(innerWidth + 2)}╯`
+  ];
+}
+function buildSectionTitle(title) {
+  return [title, `${"─".repeat(title.length)}`];
+}
+
+// src/reporting/render-shared-sections.ts
+function renderPanel(title, lines, options) {
+  return buildPanel(title, lines).map((line) => paint(line, "frame", options));
+}
+function renderSectionTitle(title, options) {
+  const [headingLine, ruleLine] = buildSectionTitle(title);
+  return [
+    paint(headingLine ?? title, "heading", options),
+    dim(ruleLine ?? "", options)
+  ];
+}
+
+// src/reporting/render-rhythm-section.ts
+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;
+  const idleLabel = report.hasWakeWindow ? "idle" : "quiet";
+  return [
+    ...renderSectionTitle("24h Rhythm", options),
+    paint(`  hours  ${buildHourMarkerLine(report)}`, "muted", options),
+    renderRhythmRow("focus", buildSparkline(report.buckets.map((bucket) => bucket.engagedMs)), formatDurationCompact(report.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + bucket.engagedMs, 0)), "focus", options),
+    renderRhythmRow("active", buildSparkline(report.buckets.map((bucket) => bucket.directActivityMs)), formatDurationCompact(report.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + bucket.directActivityMs, 0)), "active", options),
+    renderRhythmRow(padRight(idleLabel, 6).trimEnd(), buildSparkline(idleValues), formatDurationCompact(idleValues.reduce((totalDurationMs, idleDurationMs) => totalDurationMs + idleDurationMs, 0)), "idle", options),
+    renderRhythmRow("burn", buildSparkline(report.buckets.map((bucket) => bucket.practicalBurn)), formatCompactInteger(report.buckets.reduce((totalBurn, bucket) => totalBurn + bucket.practicalBurn, 0)), "burn", options)
+  ];
+}
+function buildHourMarkerLine(report) {
+  const markerCharacters = Array.from({ length: report.buckets.length }, () => " ");
+  for (const [index, bucket] of report.buckets.entries()) {
+    if (index % 4 !== 0) {
+      continue;
+    }
+    const hourLabel = formatHourOfDay(bucket.start, report.window);
+    markerCharacters[index] = hourLabel[0] ?? " ";
+    if (index + 1 < markerCharacters.length) {
+      markerCharacters[index + 1] = hourLabel[1] ?? " ";
+    }
+  }
+  return markerCharacters.join("");
+}
+function renderRhythmRow(label, sparkline, totalText, role, options) {
+  return `${paint(`  ${padRight(label, 6)}`, role, options)} ${paint(sparkline, role, options)}  ${paint(totalText, "value", options)}`;
+}
+
+// src/reporting/render-spike-section.ts
+function buildSpikeSection(report, options) {
+  const spikeBuckets = [...report.buckets].filter((bucket) => bucket.practicalBurn > 0).sort((leftBucket, rightBucket) => rightBucket.practicalBurn - leftBucket.practicalBurn).slice(0, 3);
+  if (spikeBuckets.length === 0) {
+    return [];
+  }
+  return [
+    ...renderSectionTitle("Spike Callouts", options),
+    ...spikeBuckets.map((bucket, index) => `${paint(`  #${index + 1}`, "burn", options)} ${paint(padRight(formatHourBucketLabel(bucket.start, report.window), 8), "value", options)} ${paint(padRight(formatCompactInteger(bucket.practicalBurn), 7), "burn", options)} burn  ${paint(padRight(formatDurationCompact(bucket.directActivityMs), 5), "active", options)} direct  ${paint(padRight(formatDurationCompact(bucket.engagedMs), 5), "focus", options)} focus  ${paint(`${bucket.peakConcurrentAgents}`.padStart(2), "agent", options)} peak`)
+  ];
+}
+
+// src/reporting/render-hourly-report.ts
+var barWidth = 10;
+function renderHourlyReport(report, options) {
+  return options.shareMode ? renderShareHourlyReport(report, options) : renderFullHourlyReport(report, options);
+}
+function renderFullHourlyReport(report, options) {
+  const lines = [];
+  const peakBurnBucket = report.buckets.reduce((currentPeak, bucket) => bucket.practicalBurn > currentPeak.practicalBurn ? bucket : currentPeak, report.buckets[0]);
+  const peakFocusBucket = report.buckets.reduce((currentPeak, bucket) => bucket.engagedMs > currentPeak.engagedMs ? bucket : currentPeak, report.buckets[0]);
+  lines.push(...renderPanel(`idletime hourly • ${report.window.label}`, [
+    `${formatTimestamp(report.window.start, report.window)} -> ${formatTimestamp(report.window.end, report.window)}`,
+    buildFilterLine(report),
+    `peaks burn ${formatCompactInteger(peakBurnBucket.practicalBurn)} @ ${formatHourBucketLabel(peakBurnBucket.start, report.window)} • focus ${formatDurationCompact(peakFocusBucket.engagedMs)} @ ${formatHourBucketLabel(peakFocusBucket.start, report.window)} • concurrency ${Math.max(...report.buckets.map((bucket) => bucket.peakConcurrentAgents), 0)}`
+  ], options));
+  lines.push("");
+  lines.push(...buildRhythmSection(report, options));
+  lines.push("");
+  lines.push(...buildSpikeSection(report, options));
+  lines.push("");
+  lines.push(...renderSectionTitle("Legend", options));
+  lines.push(dim("  E engaged  D direct  A agent-only  B practical burn", options));
+  lines.push("");
+  lines.push(...renderSectionTitle("Hourly View", options));
+  lines.push(dim("  hour      E                      D                      A                      B                s   p", options));
+  for (const bucket of report.buckets) {
+    lines.push(`  ${paint(padRight(formatHourBucketLabel(bucket.start, report.window), 8), "muted", options)}  ${paint("E", "focus", options)} ${paint(buildBar(bucket.engagedMs, report.maxValues.engagedMs, barWidth, "█"), "focus", options)} ${paint(padRight(formatDurationCompact(bucket.engagedMs), 5), "value", options)}  ${paint("D", "active", options)} ${paint(buildBar(bucket.directActivityMs, report.maxValues.directActivityMs, barWidth, "▓"), "active", options)} ${paint(padRight(formatDurationCompact(bucket.directActivityMs), 5), "value", options)}  ${paint("A", "agent", options)} ${paint(buildBar(bucket.agentOnlyMs, report.maxValues.agentOnlyMs, barWidth, "▒"), "agent", options)} ${paint(padRight(formatDurationCompact(bucket.agentOnlyMs), 5), "value", options)}  ${paint("B", "burn", options)} ${paint(buildBar(bucket.practicalBurn, report.maxValues.practicalBurn, barWidth, "▇"), "burn", options)} ${paint(padRight(formatCompactInteger(bucket.practicalBurn), 8), "value", options)} ${paint(bucket.sessionCount.toString().padStart(3), "value", options)} ${paint(bucket.peakConcurrentAgents.toString().padStart(3), "agent", options)}`);
+  }
+  return lines.join(`
+`);
+}
+function renderShareHourlyReport(report, options) {
+  const lines = [];
+  const peakBurnBucket = report.buckets.reduce((currentPeak, bucket) => bucket.practicalBurn > currentPeak.practicalBurn ? bucket : currentPeak, report.buckets[0]);
+  lines.push(...renderPanel(`idletime hourly • ${report.window.label}`, [
+    `${formatTimestamp(report.window.start, report.window)} -> ${formatTimestamp(report.window.end, report.window)}`,
+    buildFilterLine(report),
+    `peak burn ${formatCompactInteger(peakBurnBucket.practicalBurn)} @ ${formatHourBucketLabel(peakBurnBucket.start, report.window)}`
+  ], options));
+  lines.push("");
+  lines.push(...buildRhythmSection(report, options));
+  lines.push("");
+  lines.push(...buildSpikeSection(report, options));
+  return lines.join(`
+`);
+}
+function buildFilterLine(report) {
+  const filterParts = [
+    `${Math.round(report.idleCutoffMs / 60000)}m cutoff`
+  ];
+  if (report.appliedFilters.workspaceOnlyPrefix) {
+    filterParts.push(`workspace ${shortenPath(report.appliedFilters.workspaceOnlyPrefix, 36)}`);
+  }
+  if (report.appliedFilters.sessionKind) {
+    filterParts.push(`kind ${report.appliedFilters.sessionKind}`);
+  }
+  if (report.appliedFilters.model) {
+    filterParts.push(`model ${report.appliedFilters.model}`);
+  }
+  if (report.appliedFilters.reasoningEffort) {
+    filterParts.push(`effort ${report.appliedFilters.reasoningEffort}`);
+  }
+  return filterParts.join(" • ");
+}
+
+// src/cli/run-hourly-command.ts
+async function runHourlyCommand(command) {
+  const window = resolveTrailingReportWindow({ durationMs: command.hourlyWindowMs });
+  const sessions = await readCodexSessions({
+    windowStart: window.start,
+    windowEnd: window.end
+  });
+  return renderHourlyReport(buildHourlyReport(sessions, {
+    filters: command.filters,
+    idleCutoffMs: command.idleCutoffMs,
+    wakeWindow: command.wakeWindow,
+    window
+  }), createRenderOptions(command.shareMode));
+}
+
+// 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
+  };
+  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
+  };
+}
+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 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 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 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 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]));
+  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)
+  };
+}
+
+// src/reporting/render-summary-report.ts
+var summaryBarWidth = 18;
+function renderSummaryReport(report, options, hourlyReport) {
+  return options.shareMode ? renderShareSummaryReport(report, options, hourlyReport) : renderFullSummaryReport(report, options, hourlyReport);
+}
+function renderFullSummaryReport(report, options, hourlyReport) {
+  const lines = [];
+  const requestedMetrics = report.metrics;
+  const actualComparisonMetrics = report.comparisonMetrics;
+  const windowDurationMs = report.window.end.getTime() - report.window.start.getTime();
+  const headerLines = [
+    formatTimeRange(report.window.start, report.window.end, report.window),
+    report.activityWindow ? `active ${formatTimeRange(report.activityWindow.start, report.activityWindow.end, report.window)}` : "active no matching sessions",
+    buildHeaderMeta(report),
+    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
+  ];
+  if (hourlyReport) {
+    headerLines.push(buildPeakLine(hourlyReport));
+  }
+  lines.push(...renderPanel(`idletime • ${report.window.label}`, headerLines, options));
+  if (hourlyReport) {
+    lines.push("");
+    lines.push(...buildRhythmSection(hourlyReport, options));
+    lines.push("");
+    lines.push(...buildSpikeSection(hourlyReport, options));
+  }
+  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));
+  lines.push(renderMetricRow("all raw", report.tokenTotals.rawTotalTokens, maxRawValue, formatCompactInteger(report.tokenTotals.rawTotalTokens), `${formatInteger(report.tokenTotals.rawTotalTokens)} total`, "▓", "burn", options));
+  lines.push(renderMetricRow("direct burn", report.directTokenTotals.practicalBurn, maxBurnValue, formatCompactInteger(report.directTokenTotals.practicalBurn), `${formatPercentage(report.directTokenTotals.practicalBurn / report.tokenTotals.practicalBurn)} of burn`, "▒", "burn", options));
+  lines.push(renderMetricRow("direct raw", report.directTokenTotals.rawTotalTokens, maxRawValue, formatCompactInteger(report.directTokenTotals.rawTotalTokens), `${formatPercentage(report.directTokenTotals.rawTotalTokens / report.tokenTotals.rawTotalTokens)} of raw`, "▚", "burn", options));
+  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 renderShareSummaryReport(report, options, hourlyReport) {
+  const lines = [];
+  const headerLines = [
+    formatTimeRange(report.window.start, report.window.end, report.window),
+    report.activityWindow ? `active ${formatTimeRange(report.activityWindow.start, report.activityWindow.end, report.window)}` : "active no matching sessions",
+    buildHeaderMeta(report),
+    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
+  ];
+  if (hourlyReport) {
+    headerLines.push(buildPeakLine(hourlyReport));
+  }
+  lines.push(...renderPanel(`idletime • ${report.window.label}`, headerLines, options));
+  if (hourlyReport) {
+    lines.push("");
+    lines.push(...buildRhythmSection(hourlyReport, options));
+    lines.push("");
+    lines.push(...buildSpikeSection(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 formatDurationLabel(durationMs) {
+  return `${Math.round(durationMs / 60000)}m`;
+}
+function buildHeaderMeta(report) {
+  return `${report.sessionCounts.total} sessions • ${report.sessionCounts.direct} direct • ${report.sessionCounts.subagent} subagent • peak ${report.metrics.peakConcurrentAgents} agents`;
+}
+function buildPeakLine(report) {
+  const peakBurnBucket = report.buckets.reduce((currentPeak, bucket) => bucket.practicalBurn > currentPeak.practicalBurn ? bucket : currentPeak, report.buckets[0]);
+  const peakFocusBucket = report.buckets.reduce((currentPeak, bucket) => bucket.engagedMs > currentPeak.engagedMs ? bucket : currentPeak, report.buckets[0]);
+  return `peaks burn ${formatCompactInteger(peakBurnBucket.practicalBurn)} @ ${formatHourOfDay(peakBurnBucket.start, report.window)} • focus ${formatDurationCompact(peakFocusBucket.engagedMs)} @ ${formatHourOfDay(peakFocusBucket.start, report.window)}`;
+}
+function renderMetricRow(label, value, maxValue, primaryText, detailText, filledCharacter, role, options) {
+  return `${paint(padRight(`  ${label}`, 14), "muted", options)} ${paint(buildBar(value, maxValue, summaryBarWidth, filledCharacter), role, options)}  ${paint(padRight(primaryText, 7), "value", 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 runLast24hCommand(command) {
+  const window = resolveTrailingReportWindow({ durationMs: command.hourlyWindowMs });
+  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);
+}
+
+// src/cli/run-today-command.ts
+async function runTodayCommand(command) {
+  const window = resolveTodayReportWindow();
+  const sessions = await readCodexSessions({
+    windowStart: window.start,
+    windowEnd: window.end
+  });
+  return renderSummaryReport(buildSummaryReport(sessions, {
+    filters: command.filters,
+    groupBy: command.groupBy,
+    idleCutoffMs: command.idleCutoffMs,
+    wakeWindow: command.wakeWindow,
+    window
+  }), createRenderOptions(command.shareMode));
+}
+
+// src/cli/run-idletime.ts
+async function runIdletimeCli(argv) {
+  const command = parseIdletimeCommand(argv);
+  if (command.helpRequested) {
+    console.log(renderHelpText());
+    return;
+  }
+  if (command.versionRequested) {
+    console.log(package_default.version);
+    return;
+  }
+  const output = command.commandName === "hourly" ? await runHourlyCommand(command) : command.commandName === "today" ? await runTodayCommand(command) : await runLast24hCommand(command);
+  console.log(output);
+}
+
+// src/cli/idletime-bin.ts
+await runIdletimeCli(process.argv.slice(2));