idletime 0.1.1 → 0.1.3

package/README.md

@@ -64,6 +64,7 @@ bun run idletime
 
 That shows:
 
+- A gold `BEST` plaque in the header for your top concurrent agents, top 24-hour raw burn, and top agent-sum record
 - A framed trailing-24h dashboard
 - A `24h Rhythm` strip for `focus`, `active`, `quiet` or `idle`, and `burn`
 - `Spike Callouts` for the biggest burn hours
@@ -171,6 +172,20 @@ Once published, that also works as:
 idletime --version
 ```
 
+## Record Tracking
+
+`idletime` now keeps a local personal-best ledger under `~/.idletime/`.
+
+- `bests-v1.json`: durable best values for the header plaque
+- `best-events.ndjson`: append-only new-best history
+- `near-best-notifications-v1.json`: opt-in state for “close to best” nudges
+
+By default:
+
+- the `BEST` plaque is always shown in the normal header
+- genuine new-best events can trigger a local macOS notification
+- near-best nudges are stored but disabled until you opt in by setting `nearBestEnabled` to `true`
+
 ## Validation
 
 ```bash
@@ -178,6 +193,19 @@ bun run typecheck
 bun test
 ```
 
+Release QA:
+
+```bash
+bun run qa
+```
+
+That QA pass reads:
+
+- `qa/data/user-journeys.csv` for installed-binary shell journeys
+- `qa/data/coverage-matrix.csv` for required release coverage rows
+
+It builds the package, packs the current checkout, installs the tarball into an isolated temp `BUN_INSTALL`, seeds synthetic Codex session logs, and runs the shell journeys against the installed `idletime` binary.
+
 ## Release Prep
 
 Build the publishable CLI bundle:
@@ -192,6 +220,13 @@ Dry-run the release checks:
 bun run check:release
 ```
 
+`check:release` now runs:
+
+- `bun run typecheck`
+- `bun test`
+- `bun run qa`
+- `npm pack --dry-run`
+
 Dry-run the Bun publish flow:
 
 ```bash
@@ -206,11 +241,15 @@ bun run pack:dry-run
 
 ## GitHub Release Flow
 
-This repo now includes a publish workflow at `.github/workflows/publish.yml`.
+This repo now includes:
+
+- `.github/workflows/ci.yml` for push and pull-request release checks
+- `.github/workflows/publish.yml` for the actual npm publish flow
 
 What it does:
 
-- runs on manual dispatch or GitHub release publish
+- `ci.yml` runs on pushes to `dev` and `main`, plus pull requests
+- `publish.yml` runs on manual dispatch or GitHub release publish
 - installs Bun and Node on a GitHub-hosted runner
 - runs `bun run check:release`
 - publishes to npm with `npm publish --access public --provenance`

package/assets/idle-time-notification-icon.svg

@@ -0,0 +1,33 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="256" height="256" viewBox="0 0 256 256" fill="none">
+  <defs>
+    <linearGradient id="bg" x1="24" y1="20" x2="228" y2="236" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#202611"/>
+      <stop offset="1" stop-color="#12160A"/>
+    </linearGradient>
+    <linearGradient id="glow" x1="44" y1="42" x2="212" y2="220" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#C7BC61"/>
+      <stop offset="1" stop-color="#786B2A"/>
+    </linearGradient>
+    <linearGradient id="top" x1="128" y1="62" x2="128" y2="116" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#F0E6AB"/>
+      <stop offset="1" stop-color="#D7C770"/>
+    </linearGradient>
+    <linearGradient id="left" x1="90" y1="92" x2="118" y2="196" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#D0BC58"/>
+      <stop offset="1" stop-color="#937F34"/>
+    </linearGradient>
+    <linearGradient id="right" x1="166" y1="92" x2="138" y2="198" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#BFA747"/>
+      <stop offset="1" stop-color="#6E5E22"/>
+    </linearGradient>
+  </defs>
+  <rect x="16" y="16" width="224" height="224" rx="44" fill="url(#bg)"/>
+  <rect x="26" y="26" width="204" height="204" rx="34" stroke="url(#glow)" stroke-opacity=".42" stroke-width="4"/>
+  <rect x="42" y="42" width="172" height="22" rx="11" fill="url(#glow)" fill-opacity=".34"/>
+  <path d="M128 58 184 90 128 122 72 90 128 58Z" fill="url(#top)"/>
+  <path d="M72 90 128 122V190L72 158V90Z" fill="url(#left)"/>
+  <path d="M184 90 128 122V190L184 158V90Z" fill="url(#right)"/>
+  <path d="M128 58 184 90 128 122 72 90 128 58Z" stroke="#F5EDBD" stroke-opacity=".74" stroke-width="3"/>
+  <path d="M72 90 128 122M184 90 128 122M128 122V190" stroke="#FFF5C5" stroke-opacity=".42" stroke-width="3"/>
+  <path d="M86 178h84" stroke="#FFF0AB" stroke-opacity=".24" stroke-width="6" stroke-linecap="round"/>
+</svg>

package/dist/idletime.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "idletime",
-  version: "0.1.1",
+  version: "0.1.3",
   description: "Visual CLI for Codex focus, token burn, spikes, and idle time from local session logs.",
   author: "ParkerRex",
   main: "./dist/idletime.js",
@@ -46,12 +46,15 @@ var package_default = {
   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",
+    "check:release": "bun run build && bun run typecheck && bun test && bun run qa && npm pack --dry-run",
     dev: "bun run src/cli/idletime-bin.ts",
     idletime: "bun run src/cli/idletime-bin.ts",
-    "pack:dry-run": "npm pack --dry-run",
+    "pack:dry-run": "bun run build && npm pack --dry-run",
     "publish:dry-run": "bun run build && bun publish --dry-run --access public",
     prepublishOnly: "bun run check:release",
+    qa: "bun run qa:gaps && bun run qa:journeys",
+    "qa:gaps": "bun run qa/find-gaps.ts",
+    "qa:journeys": "bun run qa/run-shell-journeys.ts",
     test: "bun test",
     typecheck: "tsc --noEmit"
   },
@@ -518,6 +521,16 @@ function parseCodexLogLine(lineText, sourceFilePath, lineNumber) {
 }
 
 // src/codex-session-log/token-usage.ts
+function zeroTokenUsage() {
+  return {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 0,
+    practicalBurn: 0
+  };
+}
 function readTokenUsage(value, label) {
   const record = expectObject(value, label);
   const inputTokens = readNumber(record, "input_tokens", label);
@@ -545,7 +558,7 @@ function subtractTokenUsages(currentUsage, previousUsage) {
   };
   for (const [key, value] of Object.entries(nextUsage)) {
     if (value < 0) {
-      throw new Error(`Token usage regressed for ${key}.`);
+      return null;
     }
   }
   return nextUsage;
@@ -567,9 +580,11 @@ function extractTokenPoints(records) {
       continue;
     }
     const infoRecord = expectObject(info, "event_msg.payload.info");
+    const lastUsageValue = infoRecord.last_token_usage;
     tokenPoints.push({
       timestamp: record.timestamp,
-      usage: readTokenUsage(infoRecord.total_token_usage, "event_msg.payload.info.total_token_usage")
+      usage: readTokenUsage(infoRecord.total_token_usage, "event_msg.payload.info.total_token_usage"),
+      lastUsage: lastUsageValue === null || lastUsageValue === undefined ? null : readTokenUsage(lastUsageValue, "event_msg.payload.info.last_token_usage")
     });
   }
   return tokenPoints.sort((leftPoint, rightPoint) => leftPoint.timestamp.getTime() - rightPoint.timestamp.getTime());
@@ -581,12 +596,21 @@ function buildTokenDeltaPoints(tokenPoints) {
     deltaPoints.push({
       timestamp: tokenPoint.timestamp,
       cumulativeUsage: tokenPoint.usage,
-      deltaUsage: previousPoint ? subtractTokenUsages(tokenPoint.usage, previousPoint.usage) : tokenPoint.usage
+      deltaUsage: resolveTokenDeltaUsage(tokenPoint, previousPoint)
     });
     previousPoint = tokenPoint;
   }
   return deltaPoints;
 }
+function resolveTokenDeltaUsage(tokenPoint, previousPoint) {
+  if (tokenPoint.lastUsage) {
+    return tokenPoint.lastUsage;
+  }
+  if (!previousPoint) {
+    return tokenPoint.usage;
+  }
+  return subtractTokenUsages(tokenPoint.usage, previousPoint.usage) ?? zeroTokenUsage();
+}
 
 // src/codex-session-log/extract-turn-attribution.ts
 function extractTurnAttribution(records) {
@@ -1037,18 +1061,66 @@ function shortenPath(pathText, maxLength) {
   return `...${shortenedPath || pathText.slice(-(maxLength - 3))}`;
 }
 
+// src/reporting/render-best-plaque.ts
+function buildBestPlaque(ledger) {
+  return {
+    label: "BEST",
+    concurrentAgentsText: `${formatInteger(ledger?.bestConcurrentAgents?.value ?? 0)} concurrent agents`,
+    rawBurnText: `${formatCompactInteger(ledger?.best24hRawBurn?.value ?? 0).toUpperCase()} 24hr raw burn`,
+    agentSumText: `${formatAgentSumHours(ledger?.best24hAgentSumMs?.value ?? 0)} agent sum`
+  };
+}
+function buildBestPlaqueRows(bestPlaque, availableWidth) {
+  const wideRows = [
+    bestPlaque.label,
+    bestPlaque.concurrentAgentsText,
+    bestPlaque.rawBurnText,
+    bestPlaque.agentSumText,
+    ""
+  ];
+  if (rowsFitWidth(wideRows, availableWidth)) {
+    return wideRows;
+  }
+  const compactRows = [
+    bestPlaque.label,
+    bestPlaque.concurrentAgentsText.replace(" agents", ""),
+    bestPlaque.rawBurnText.replace(" 24hr ", " "),
+    bestPlaque.agentSumText,
+    ""
+  ];
+  if (rowsFitWidth(compactRows, availableWidth)) {
+    return compactRows;
+  }
+  const microRows = [
+    bestPlaque.label,
+    compactRows[1]?.replace("concurrent", "conc") ?? "",
+    compactRows[2]?.replace(" burn", "") ?? "",
+    compactRows[3]?.replace(" agent sum", " sum") ?? "",
+    ""
+  ];
+  return rowsFitWidth(microRows, availableWidth) ? microRows : null;
+}
+function formatAgentSumHours(durationMs) {
+  const hours = durationMs / 3600000;
+  const roundedHours = hours >= 10 ? Math.round(hours).toString() : (Math.round(hours * 10) / 10).toString();
+  return roundedHours.endsWith(".0") ? roundedHours.slice(0, -2) : roundedHours;
+}
+function rowsFitWidth(rows, availableWidth) {
+  return availableWidth > 0 && rows.every((row) => row.length <= availableWidth);
+}
+
 // src/reporting/render-theme.ts
 var roleStyles = {
-  focus: "1;38;2;236;239;148",
-  active: "1;38;2;208;219;96",
-  agent: "1;38;2;166;182;77",
-  idle: "1;38;2;138;150;66",
-  burn: "1;38;2;228;209;92",
-  raw: "1;38;2;188;172;80",
-  frame: "1;38;2;149;158;56",
-  heading: "1;38;2;249;246;212",
-  muted: "38;2;142;145;96",
-  value: "1;38;2;242;236;179"
+  focus: "1;38;2;190;184;86",
+  active: "1;38;2;157;168;60",
+  agent: "1;38;2;124;138;55",
+  idle: "1;38;2;105;118;50",
+  burn: "1;38;2;190;161;55",
+  raw: "1;38;2;153;132;52",
+  frame: "1;38;2;118;126;50",
+  heading: "1;38;2;201;190;102",
+  muted: "38;2;111;115;78",
+  value: "1;38;2;178;161;68"
 };
 function createRenderOptions(shareMode) {
   return {
@@ -1086,7 +1158,9 @@ function measureVisibleTextWidth(text) {
 
 // src/reporting/render-logo-section.ts
 var baseBackgroundStyle = "48;2;12;15;8";
-var wordmarkStyle = `${baseBackgroundStyle};1;38;2;247;245;204`;
+var plaqueInsetColumns = 3;
+var plaqueTextStyle = "1;38;2;244;235;164";
+var wordmarkStyle = `${baseBackgroundStyle};1;38;2;210;198;108`;
 var wordmarkLines = [
   "       ▄▄ ▄▄",
   "▀▀     ██ ██        ██   ▀▀",
@@ -1096,59 +1170,76 @@ var wordmarkLines = [
 ];
 var patternColors = [
   { red: 20, green: 24, blue: 10 },
-  { red: 48, green: 58, blue: 18 },
-  { red: 86, green: 96, blue: 24 },
-  { red: 128, green: 138, blue: 30 },
-  { red: 176, green: 188, blue: 40 },
-  { red: 220, green: 228, blue: 78 }
+  { red: 42, green: 50, blue: 16 },
+  { red: 71, green: 81, blue: 24 },
+  { red: 101, green: 112, blue: 31 },
+  { red: 136, green: 145, blue: 39 },
+  { red: 177, green: 169, blue: 58 }
 ];
 var monochromePatternCharacters = ["░", "░", "▒", "▓", "█"];
-function buildLogoSection(requestedWidth, options) {
+function buildLogoSection(requestedWidth, options, bestPlaque = null) {
   const wordmarkWidth = Math.max(...wordmarkLines.map((line) => line.length));
   const sectionWidth = Math.max(requestedWidth, wordmarkWidth);
   const patternWidth = Math.max(0, sectionWidth - wordmarkWidth);
+  const plaqueRows = bestPlaque ? buildBestPlaqueRows(bestPlaque, Math.max(0, patternWidth - plaqueInsetColumns)) : null;
   return wordmarkLines.map((line, rowIndex) => {
     const paddedWordmark = padRight(line, wordmarkWidth);
-    const patternTail = buildPatternTail(patternWidth, rowIndex, options);
+    const patternTail = buildPatternTail(patternWidth, rowIndex, options, plaqueRows?.[rowIndex] ?? "");
     return `${paintAnsi(paddedWordmark, wordmarkStyle, options)}${patternTail}`;
   });
 }
 function resolveLogoSectionWidth(minimumWidth, options) {
   return Math.max(minimumWidth, options.terminalWidth ?? 0);
 }
-function buildPatternTail(width, rowIndex, options) {
+function buildPatternTail(width, rowIndex, options, plaqueRowText) {
   if (!options.colorEnabled) {
-    return buildMonochromePatternTail(width, rowIndex);
+    return buildMonochromePatternTail(width, rowIndex, plaqueRowText);
   }
+  const overlayCharacters = createOverlayCharacters(width, plaqueRowText);
+  const cellStyles = Array.from({ length: width }, (_, columnIndex) => getPatternCellStyle(getPatternIntensity(width, rowIndex, columnIndex)));
   let patternTail = "";
   let currentStyle = "";
-  let currentSegmentWidth = 0;
+  let currentSegment = "";
   for (let columnIndex = 0;columnIndex < width; columnIndex += 1) {
-    const style = getPatternCellStyle(getPatternIntensity(width, rowIndex, columnIndex));
+    const overlayCharacter = overlayCharacters[columnIndex];
+    const style = overlayCharacter === null ? cellStyles[columnIndex] : `${cellStyles[columnIndex]};${plaqueTextStyle}`;
     if (style === currentStyle) {
-      currentSegmentWidth += 1;
+      currentSegment += overlayCharacter ?? " ";
       continue;
     }
-    if (currentSegmentWidth > 0) {
-      patternTail += paintAnsi(" ".repeat(currentSegmentWidth), currentStyle, options);
+    if (currentSegment.length > 0) {
+      patternTail += paintAnsi(currentSegment, currentStyle, options);
     }
     currentStyle = style;
-    currentSegmentWidth = 1;
+    currentSegment = overlayCharacter ?? " ";
   }
-  if (currentSegmentWidth > 0) {
-    patternTail += paintAnsi(" ".repeat(currentSegmentWidth), currentStyle, options);
+  if (currentSegment.length > 0) {
+    patternTail += paintAnsi(currentSegment, currentStyle, options);
   }
   return patternTail;
 }
-function buildMonochromePatternTail(width, rowIndex) {
+function buildMonochromePatternTail(width, rowIndex, plaqueRowText) {
+  const overlayCharacters = createOverlayCharacters(width, plaqueRowText);
   let patternTail = "";
   for (let columnIndex = 0;columnIndex < width; columnIndex += 1) {
+    const overlayCharacter = overlayCharacters[columnIndex];
+    if (overlayCharacter !== null) {
+      patternTail += overlayCharacter;
+      continue;
+    }
     const intensity = getPatternIntensity(width, rowIndex, columnIndex);
     const characterIndex = Math.min(monochromePatternCharacters.length - 1, Math.floor(intensity * monochromePatternCharacters.length));
     patternTail += monochromePatternCharacters[characterIndex];
   }
   return patternTail;
 }
+function createOverlayCharacters(width, plaqueRowText) {
+  const overlayCharacters = Array.from({ length: width }, () => null);
+  for (let index = 0;index < plaqueRowText.length && plaqueInsetColumns + index < width; index += 1) {
+    overlayCharacters[plaqueInsetColumns + index] = plaqueRowText[index];
+  }
+  return overlayCharacters;
+}
 function getPatternIntensity(width, rowIndex, columnIndex) {
   const normalizedColumn = width <= 1 ? 0 : columnIndex / Math.max(1, width - 1);
   const envelope = 0.18 + 0.82 * Math.pow(normalizedColumn, 0.82);
@@ -1331,6 +1422,631 @@ async function runHourlyCommand(command) {
   }), createRenderOptions(command.shareMode));
 }
 
+// src/best-metrics/notification-delivery.ts
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function deliverLocalNotifications(notifications, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "darwin" || notifications.length === 0) {
+    return;
+  }
+  const notifier = options.notifier ?? sendMacOsNotification;
+  for (const notification of notifications) {
+    try {
+      await notifier(notification);
+    } catch {
+      return;
+    }
+  }
+}
+async function sendMacOsNotification(notification) {
+  const notificationIconPath = resolveNotificationIconPath();
+  try {
+    await execFileAsync("terminal-notifier", [
+      "-title",
+      notification.title,
+      "-message",
+      notification.body,
+      ...notificationIconPath ? ["-appIcon", pathToFileURL(notificationIconPath).href] : []
+    ]);
+    return;
+  } catch (error) {
+    if (!isCommandMissingError(error)) {
+      throw error;
+    }
+  }
+  await execFileAsync("osascript", [
+    "-e",
+    `display notification "${escapeAppleScriptText(notification.body)}" with title "${escapeAppleScriptText(notification.title)}"`
+  ]);
+}
+function escapeAppleScriptText(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+}
+function resolveNotificationIconPath() {
+  const candidatePaths = [
+    fileURLToPath(new URL("../../assets/idle-time-notification-icon.png", import.meta.url)),
+    fileURLToPath(new URL("../assets/idle-time-notification-icon.png", import.meta.url))
+  ];
+  return candidatePaths.find((candidatePath) => existsSync(candidatePath)) ?? null;
+}
+function isCommandMissingError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/best-metrics/near-best-notifications.ts
+import { mkdir, readFile as 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 [];
+  }
+  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 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}.`);
+  }
+  const lastNotifiedAtRecord = expectObject(stateRecord.lastNotifiedAt, "nearBestNotificationState.lastNotifiedAt");
+  return {
+    version,
+    nearBestEnabled: Boolean(stateRecord.nearBestEnabled),
+    thresholdRatio: readNumber(stateRecord, "thresholdRatio", "nearBestNotificationState"),
+    cooldownMs: readNumber(stateRecord, "cooldownMs", "nearBestNotificationState"),
+    lastNotifiedAt: {
+      bestConcurrentAgents: readOptionalIsoTimestamp(lastNotifiedAtRecord.bestConcurrentAgents, "nearBestNotificationState.lastNotifiedAt.bestConcurrentAgents"),
+      best24hRawBurn: readOptionalIsoTimestamp(lastNotifiedAtRecord.best24hRawBurn, "nearBestNotificationState.lastNotifiedAt.best24hRawBurn"),
+      best24hAgentSumMs: readOptionalIsoTimestamp(lastNotifiedAtRecord.best24hAgentSumMs, "nearBestNotificationState.lastNotifiedAt.best24hAgentSumMs")
+    }
+  };
+}
+async function writeNearBestNotificationState(state, options) {
+  const statePath = resolveNearBestNotificationStatePath(options);
+  const stateDirectory = options.stateDirectory ?? 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 buildNearBestMetricKeys(currentMetrics, ledger, state, now) {
+  return [
+    "bestConcurrentAgents",
+    "best24hRawBurn",
+    "best24hAgentSumMs"
+  ].filter((metric) => {
+    const bestValue = ledger[metric]?.value ?? 0;
+    if (bestValue <= 0) {
+      return false;
+    }
+    const currentValue = currentMetrics[metric];
+    if (currentValue <= 0 || currentValue >= bestValue) {
+      return false;
+    }
+    if (currentValue / bestValue < state.thresholdRatio) {
+      return false;
+    }
+    const lastNotifiedAt = state.lastNotifiedAt[metric];
+    return lastNotifiedAt === null || now.getTime() - lastNotifiedAt.getTime() >= state.cooldownMs;
+  });
+}
+function buildNearBestNotification(metric, currentValue, bestValue) {
+  return {
+    title: metric === "bestConcurrentAgents" ? "Close to best concurrent agents" : metric === "best24hRawBurn" ? "Close to best 24hr raw burn" : "Close to best agent sum",
+    body: metric === "bestConcurrentAgents" ? `${formatInteger2(currentValue)} of ${formatInteger2(bestValue)} concurrent agents` : metric === "best24hRawBurn" ? `${formatCompactInteger2(currentValue)} of ${formatCompactInteger2(bestValue)} 24hr raw burn` : `${formatAgentSumHours2(currentValue)} of ${formatAgentSumHours2(bestValue)} agent sum`
+  };
+}
+function createDefaultNearBestNotificationState() {
+  return {
+    version: nearBestNotificationVersion,
+    nearBestEnabled: false,
+    thresholdRatio: 0.97,
+    cooldownMs: 24 * 60 * 60 * 1000,
+    lastNotifiedAt: {
+      bestConcurrentAgents: null,
+      best24hRawBurn: null,
+      best24hAgentSumMs: null
+    }
+  };
+}
+function resolveNearBestNotificationStatePath(options) {
+  return join2(options.stateDirectory ?? join2(homedir2(), ".idletime"), nearBestNotificationStateFileName);
+}
+function readOptionalIsoTimestamp(value, label) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  return readIsoTimestamp(value, label);
+}
+function formatAgentSumHours2(durationMs) {
+  const hours = durationMs / 3600000;
+  return hours >= 10 ? Math.round(hours).toString() : (Math.round(hours * 10) / 10).toString();
+}
+function formatCompactInteger2(value) {
+  return new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumFractionDigits: 1
+  }).format(Math.round(value)).toUpperCase();
+}
+function formatInteger2(value) {
+  return new Intl.NumberFormat("en-US").format(Math.round(value));
+}
+
+// src/best-metrics/notify-best-events.ts
+async function notifyBestEvents(bestEvents, options = {}) {
+  await deliverLocalNotifications(bestEvents.map((bestEvent) => buildBestEventNotification(bestEvent)), options);
+}
+function buildBestEventNotification(bestEvent) {
+  return {
+    title: resolveNotificationTitle(bestEvent.metric),
+    body: resolveNotificationBody(bestEvent)
+  };
+}
+function resolveNotificationTitle(bestMetricKey) {
+  return bestMetricKey === "bestConcurrentAgents" ? "New best concurrent agents" : bestMetricKey === "best24hRawBurn" ? "New best 24hr raw burn" : "New best agent sum";
+}
+function resolveNotificationBody(bestEvent) {
+  return bestEvent.metric === "bestConcurrentAgents" ? `${formatInteger3(bestEvent.value)} concurrent agents` : bestEvent.metric === "best24hRawBurn" ? `${formatCompactInteger3(bestEvent.value)} 24hr raw burn` : `${formatAgentSumHours3(bestEvent.value)} agent sum`;
+}
+function formatAgentSumHours3(durationMs) {
+  const hours = durationMs / 3600000;
+  return hours >= 10 ? Math.round(hours).toString() : (Math.round(hours * 10) / 10).toString();
+}
+function formatCompactInteger3(value) {
+  return new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumFractionDigits: 1
+  }).format(Math.round(value)).toUpperCase();
+}
+function formatInteger3(value) {
+  return new Intl.NumberFormat("en-US").format(Math.round(value));
+}
+
+// src/best-metrics/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
+  };
+  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)
+  };
+}
+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;
+  }
+  const stateDirectory = resolveBestStateDirectory(options);
+  await mkdir2(stateDirectory, { recursive: true });
+  await appendFile(join3(stateDirectory, bestEventsFileName), `${bestEvents.map(serializeBestEvent).join(`
+`)}
+`, "utf8");
+}
+function serializeBestEvent(bestEvent) {
+  return JSON.stringify({
+    metric: bestEvent.metric,
+    previousValue: bestEvent.previousValue,
+    value: bestEvent.value,
+    observedAt: bestEvent.observedAt.toISOString(),
+    windowStart: bestEvent.windowStart.toISOString(),
+    windowEnd: bestEvent.windowEnd.toISOString(),
+    version: bestEvent.version
+  });
+}
+function resolveBestStateDirectory(options) {
+  return options.stateDirectory ?? join3(homedir3(), ".idletime");
+}
+
+// src/best-metrics/build-rolling-24h-windows.ts
+function findBestRollingWindowTotal(weightedPoints) {
+  const sortedPoints = weightedPoints.filter((point) => point.value > 0).slice().sort((leftPoint, rightPoint) => leftPoint.timestamp.getTime() - rightPoint.timestamp.getTime());
+  if (sortedPoints.length === 0) {
+    return null;
+  }
+  let bestValue = 0;
+  let bestTimestampMs = 0;
+  let currentTotal = 0;
+  let leftIndex = 0;
+  for (let rightIndex = 0;rightIndex < sortedPoints.length; rightIndex += 1) {
+    const rightPoint = sortedPoints[rightIndex];
+    currentTotal += rightPoint.value;
+    while (rightPoint.timestamp.getTime() - sortedPoints[leftIndex].timestamp.getTime() > rollingWindowDurationMs) {
+      currentTotal -= sortedPoints[leftIndex].value;
+      leftIndex += 1;
+    }
+    if (currentTotal > bestValue) {
+      bestValue = currentTotal;
+      bestTimestampMs = rightPoint.timestamp.getTime();
+    }
+  }
+  if (bestValue === 0) {
+    return null;
+  }
+  return createRollingRecord(bestValue, bestTimestampMs);
+}
+function findBestRollingWindowOverlap(intervals) {
+  const slopeChanges = intervals.flatMap(buildSlopeChanges);
+  if (slopeChanges.length === 0) {
+    return null;
+  }
+  slopeChanges.sort((leftChange, rightChange) => leftChange.timestampMs - rightChange.timestampMs);
+  let bestTimestampMs = 0;
+  let bestValue = 0;
+  let currentSlope = 0;
+  let currentValue = 0;
+  let previousTimestampMs = slopeChanges[0].timestampMs;
+  let index = 0;
+  while (index < slopeChanges.length) {
+    const timestampMs = slopeChanges[index].timestampMs;
+    currentValue += currentSlope * (timestampMs - previousTimestampMs);
+    if (currentValue > bestValue) {
+      bestValue = currentValue;
+      bestTimestampMs = timestampMs;
+    }
+    while (index < slopeChanges.length && slopeChanges[index].timestampMs === timestampMs) {
+      currentSlope += slopeChanges[index].deltaSlope;
+      index += 1;
+    }
+    previousTimestampMs = timestampMs;
+  }
+  if (bestValue === 0) {
+    return null;
+  }
+  return createRollingRecord(bestValue, bestTimestampMs);
+}
+function buildSlopeChanges(interval) {
+  const startMs = interval.start.getTime();
+  const endMs = interval.end.getTime();
+  if (endMs <= startMs) {
+    return [];
+  }
+  return [
+    { timestampMs: startMs, deltaSlope: 1 },
+    { timestampMs: endMs, deltaSlope: -1 },
+    { timestampMs: startMs + rollingWindowDurationMs, deltaSlope: -1 },
+    { timestampMs: endMs + rollingWindowDurationMs, deltaSlope: 1 }
+  ];
+}
+function createRollingRecord(value, observedAtMs) {
+  return {
+    value,
+    observedAt: new Date(observedAtMs),
+    windowStart: new Date(observedAtMs - rollingWindowDurationMs),
+    windowEnd: new Date(observedAtMs)
+  };
+}
+
+// src/best-metrics/build-best-metrics.ts
+function buildBestMetricCandidates(sessions, options = {}) {
+  const idleCutoffMs = options.idleCutoffMs ?? defaultBestMetricsIdleCutoffMs;
+  const activityMetrics = buildActivityMetrics(sessions, idleCutoffMs);
+  return {
+    bestConcurrentAgents: findBestConcurrentAgents(activityMetrics.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 findBestConcurrentAgents(intervalGroups) {
+  const concurrencyEdges = intervalGroups.flatMap((intervalGroup) => intervalGroup.flatMap((interval) => [
+    { timestampMs: interval.start.getTime(), delta: 1 },
+    { timestampMs: interval.end.getTime(), delta: -1 }
+  ]));
+  if (concurrencyEdges.length === 0) {
+    return null;
+  }
+  concurrencyEdges.sort((leftEdge, rightEdge) => leftEdge.timestampMs - rightEdge.timestampMs);
+  let activeCount = 0;
+  let bestRecord = null;
+  let index = 0;
+  while (index < concurrencyEdges.length) {
+    const timestampMs = concurrencyEdges[index].timestampMs;
+    while (index < concurrencyEdges.length && concurrencyEdges[index].timestampMs === timestampMs) {
+      activeCount += concurrencyEdges[index].delta;
+      index += 1;
+    }
+    const nextTimestampMs = concurrencyEdges[index]?.timestampMs ?? timestampMs;
+    if (nextTimestampMs <= timestampMs || activeCount <= 0) {
+      continue;
+    }
+    if (!bestRecord || activeCount > bestRecord.value) {
+      bestRecord = {
+        value: activeCount,
+        observedAt: new Date(timestampMs),
+        windowStart: new Date(timestampMs),
+        windowEnd: new Date(nextTimestampMs)
+      };
+    }
+  }
+  return bestRecord;
+}
+
+// src/best-metrics/read-all-codex-sessions.ts
+import { readdir as readdir2 } from "node:fs/promises";
+import { homedir as 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 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);
+      }
+    }
+  }
+  return sessionFiles.sort();
+}
+async function readDirectoryEntries2(directoryPath) {
+  try {
+    return await readdir2(directoryPath, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingDirectoryError2(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function isMissingDirectoryError2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/best-metrics/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 = {}) {
+  try {
+    const rawLedgerText = await readFile3(resolveBestLedgerPath(options), "utf8");
+    return parseBestLedger(JSON.parse(rawLedgerText));
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function parseBestLedger(value) {
+  const ledgerRecord = expectObject(value, "bestMetricsLedger");
+  const version = readNumber(ledgerRecord, "version", "bestMetricsLedger");
+  if (version !== bestMetricsLedgerVersion) {
+    throw new Error(`bestMetricsLedger.version must be ${bestMetricsLedgerVersion}.`);
+  }
+  return {
+    version: bestMetricsLedgerVersion,
+    initializedAt: readIsoTimestamp(ledgerRecord.initializedAt, "bestMetricsLedger.initializedAt"),
+    lastScannedAt: readIsoTimestamp(ledgerRecord.lastScannedAt, "bestMetricsLedger.lastScannedAt"),
+    bestConcurrentAgents: parseBestMetricRecord(ledgerRecord.bestConcurrentAgents, "bestMetricsLedger.bestConcurrentAgents"),
+    best24hRawBurn: parseBestMetricRecord(ledgerRecord.best24hRawBurn, "bestMetricsLedger.best24hRawBurn"),
+    best24hAgentSumMs: parseBestMetricRecord(ledgerRecord.best24hAgentSumMs, "bestMetricsLedger.best24hAgentSumMs")
+  };
+}
+function resolveBestLedgerPath(options = {}) {
+  return join5(resolveBestStateDirectory2(options), bestLedgerFileName);
+}
+function serializeBestLedger(ledger) {
+  const serializedLedger = {
+    version: ledger.version,
+    initializedAt: ledger.initializedAt.toISOString(),
+    lastScannedAt: ledger.lastScannedAt.toISOString(),
+    bestConcurrentAgents: serializeBestMetricRecord(ledger.bestConcurrentAgents),
+    best24hRawBurn: serializeBestMetricRecord(ledger.best24hRawBurn),
+    best24hAgentSumMs: serializeBestMetricRecord(ledger.best24hAgentSumMs)
+  };
+  return `${JSON.stringify(serializedLedger, null, 2)}
+`;
+}
+function parseBestMetricRecord(value, label) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  const record = expectObject(value, label);
+  return {
+    value: readNumber(record, "value", label),
+    observedAt: readIsoTimestamp(record.observedAt, `${label}.observedAt`),
+    windowStart: readIsoTimestamp(record.windowStart, `${label}.windowStart`),
+    windowEnd: readIsoTimestamp(record.windowEnd, `${label}.windowEnd`)
+  };
+}
+function serializeBestMetricRecord(record) {
+  if (!record) {
+    return null;
+  }
+  return {
+    value: record.value,
+    observedAt: record.observedAt.toISOString(),
+    windowStart: record.windowStart.toISOString(),
+    windowEnd: record.windowEnd.toISOString()
+  };
+}
+function 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);
+}
+
+// src/best-metrics/refresh-best-metrics.ts
+async function refreshBestMetrics(options = {}) {
+  const refreshedAt = options.now ?? new Date;
+  const existingLedger = await readBestLedger(options);
+  const sessions = await readAllCodexSessions({
+    sessionRootDirectory: options.sessionRootDirectory
+  });
+  const bestMetricCandidates = buildBestMetricCandidates(sessions);
+  const currentMetrics = buildCurrentBestMetricValues(sessions, {
+    now: refreshedAt
+  });
+  if (!existingLedger) {
+    const bootstrappedLedger = {
+      version: bestMetricsLedgerVersion,
+      initializedAt: refreshedAt,
+      lastScannedAt: refreshedAt,
+      ...bestMetricCandidates
+    };
+    await writeBestLedger(bootstrappedLedger, options);
+    return {
+      currentMetrics,
+      ledger: bootstrappedLedger,
+      newBestEvents: [],
+      refreshMode: "bootstrap"
+    };
+  }
+  const newBestEvents = buildNewBestEvents(existingLedger, bestMetricCandidates);
+  const refreshedLedger = {
+    ...existingLedger,
+    lastScannedAt: refreshedAt,
+    ...mergeBestMetricCandidates(existingLedger, bestMetricCandidates)
+  };
+  await writeBestLedger(refreshedLedger, options);
+  await appendBestEvents(newBestEvents, options);
+  return {
+    currentMetrics,
+    ledger: refreshedLedger,
+    newBestEvents,
+    refreshMode: "refresh"
+  };
+}
+function mergeBestMetricCandidates(currentLedger, candidateLedger) {
+  return {
+    bestConcurrentAgents: pickBetterRecord(currentLedger.bestConcurrentAgents, candidateLedger.bestConcurrentAgents),
+    best24hRawBurn: pickBetterRecord(currentLedger.best24hRawBurn, candidateLedger.best24hRawBurn),
+    best24hAgentSumMs: pickBetterRecord(currentLedger.best24hAgentSumMs, candidateLedger.best24hAgentSumMs)
+  };
+}
+function pickBetterRecord(currentRecord, candidateRecord) {
+  if (!candidateRecord) {
+    return currentRecord;
+  }
+  if (!currentRecord || candidateRecord.value > currentRecord.value) {
+    return candidateRecord;
+  }
+  return currentRecord;
+}
+function buildNewBestEvents(currentLedger, candidateLedger) {
+  return [
+    buildNewBestEvent("bestConcurrentAgents", currentLedger.bestConcurrentAgents, candidateLedger.bestConcurrentAgents),
+    buildNewBestEvent("best24hRawBurn", currentLedger.best24hRawBurn, candidateLedger.best24hRawBurn),
+    buildNewBestEvent("best24hAgentSumMs", currentLedger.best24hAgentSumMs, candidateLedger.best24hAgentSumMs)
+  ].flatMap((bestEvent) => bestEvent ? [bestEvent] : []);
+}
+function buildNewBestEvent(metric, currentRecord, candidateRecord) {
+  if (!candidateRecord || currentRecord !== null && candidateRecord.value <= currentRecord.value) {
+    return null;
+  }
+  return {
+    metric,
+    previousValue: currentRecord?.value ?? null,
+    value: candidateRecord.value,
+    observedAt: candidateRecord.observedAt,
+    windowStart: candidateRecord.windowStart,
+    windowEnd: candidateRecord.windowEnd,
+    version: bestMetricsLedgerVersion
+  };
+}
+
 // src/reporting/build-summary-report.ts
 function buildSummaryReport(sessions, query) {
   const filteredSessions = filterSessions(sessions, query.filters);
@@ -1428,23 +2144,19 @@ function clipActivityMetricsToWindow(metrics, windowInterval) {
 
 // src/reporting/render-summary-report.ts
 var summaryBarWidth = 18;
-function renderSummaryReport(report, options, hourlyReport) {
-  return options.shareMode ? renderShareSummaryReport(report, options, hourlyReport) : renderFullSummaryReport(report, options, hourlyReport);
+function renderSummaryReport(report, options, hourlyReport, bestPlaque = null) {
+  return options.shareMode ? renderShareSummaryReport(report, options, hourlyReport, bestPlaque) : renderFullSummaryReport(report, options, hourlyReport, bestPlaque);
 }
-function renderFullSummaryReport(report, options, hourlyReport) {
+function renderFullSummaryReport(report, options, hourlyReport, bestPlaque = null) {
   const lines = [];
   const requestedMetrics = report.metrics;
   const actualComparisonMetrics = report.comparisonMetrics;
   const windowDurationMs = report.window.end.getTime() - report.window.start.getTime();
-  const headerLines = [
-    formatTimeRange(report.window.start, report.window.end, report.window),
-    `${report.sessionCounts.total} sessions · ${formatDurationHours(requestedMetrics.strictEngagementMs)} focused · ${formatCompactInteger(report.tokenTotals.practicalBurn)} tokens`,
-    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
-  ];
+  const headerLines = buildSummaryHeaderLines(report, hourlyReport);
   const panelLines = renderPanel(`idletime • ${report.window.label}`, headerLines, options);
   const panelWidth = measureVisibleTextWidth(panelLines[0] ?? "");
   const logoSectionWidth = resolveLogoSectionWidth(panelWidth, options);
-  lines.push(...buildLogoSection(logoSectionWidth, options));
+  lines.push(...buildLogoSection(logoSectionWidth, options, bestPlaque));
   lines.push("");
   lines.push(...panelLines);
   if (hourlyReport) {
@@ -1495,17 +2207,13 @@ function renderFullSummaryReport(report, options, hourlyReport) {
   return lines.join(`
 `);
 }
-function renderShareSummaryReport(report, options, hourlyReport) {
+function renderShareSummaryReport(report, options, hourlyReport, bestPlaque = null) {
   const lines = [];
-  const headerLines = [
-    formatTimeRange(report.window.start, report.window.end, report.window),
-    `${report.sessionCounts.total} sessions · ${formatDurationHours(report.metrics.strictEngagementMs)} focused · ${formatCompactInteger(report.tokenTotals.practicalBurn)} tokens`,
-    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
-  ];
+  const headerLines = buildSummaryHeaderLines(report, hourlyReport);
   const panelLines = renderPanel(`idletime • ${report.window.label}`, headerLines, options);
   const panelWidth = measureVisibleTextWidth(panelLines[0] ?? "");
   const logoSectionWidth = resolveLogoSectionWidth(panelWidth, options);
-  lines.push(...buildLogoSection(logoSectionWidth, options));
+  lines.push(...buildLogoSection(logoSectionWidth, options, bestPlaque));
   lines.push("");
   lines.push(...panelLines);
   if (hourlyReport) {
@@ -1539,6 +2247,93 @@ function formatAppliedFilters(report) {
   }
   return appliedFilters;
 }
+function buildSummaryHeaderLines(report, hourlyReport) {
+  if (!hourlyReport) {
+    return [
+      formatTimeRange(report.window.start, report.window.end, report.window),
+      `${report.sessionCounts.total} sessions · ${formatDurationHours(report.metrics.strictEngagementMs)} focused · ${formatCompactInteger(report.tokenTotals.practicalBurn)} tokens`,
+      ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
+    ];
+  }
+  return [
+    buildPostureLine(report, hourlyReport),
+    buildBiggestStoryLine(report, hourlyReport),
+    buildSupportFactsLine(report),
+    ...formatAppliedFilters(report).map((filter) => `filter ${filter}`)
+  ];
+}
+function buildPostureLine(report, hourlyReport) {
+  const directActivityMs = Math.max(report.metrics.directActivityMs, 1);
+  const focusRatio = report.metrics.strictEngagementMs / directActivityMs;
+  const agentCoverageRatio = report.metrics.agentCoverageMs / directActivityMs;
+  const quietRatio = sumQuietMs(hourlyReport) / Math.max(1, report.window.end.getTime() - report.window.start.getTime());
+  const posture = quietRatio >= 0.45 ? "Fragmented day" : agentCoverageRatio >= 0.75 && focusRatio < 0.65 ? "Mostly orchestrating" : focusRatio >= 0.8 ? "Mostly in the loop" : report.metrics.peakConcurrentAgents >= 6 ? "Heavy agent day" : "Balanced day";
+  return `${posture}: ${formatDurationHours(report.metrics.strictEngagementMs)} focused, ${formatDurationHours(report.metrics.agentCoverageMs)} agent live`;
+}
+function buildBiggestStoryLine(report, hourlyReport) {
+  const longestQuietRun = findLongestQuietRun(hourlyReport);
+  const peakBurnBucket = hourlyReport.buckets.reduce((currentPeak, bucket) => bucket.practicalBurn > currentPeak.practicalBurn ? bucket : currentPeak, hourlyReport.buckets[0]);
+  const quietPhrase = longestQuietRun.durationMs >= 2 * 3600000 ? `long quiet stretch ${describeDayPeriod(longestQuietRun.start, report)}` : "steady rhythm overall";
+  return `Biggest story: ${quietPhrase}, big burn ${describeDayPeriod(peakBurnBucket.start, report)}`;
+}
+function buildSupportFactsLine(report) {
+  return `${report.sessionCounts.direct} direct / ${report.sessionCounts.subagent} subagent • ${report.metrics.peakConcurrentAgents} peak • ${formatCompactInteger(report.tokenTotals.practicalBurn)} burn`;
+}
+function sumQuietMs(hourlyReport) {
+  return hourlyReport.buckets.reduce((totalDurationMs, bucket) => totalDurationMs + Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs), 0);
+}
+function findLongestQuietRun(hourlyReport) {
+  let longestQuietRun = {
+    durationMs: 0,
+    start: hourlyReport.buckets[0]?.start ?? new Date(0)
+  };
+  let currentStart = null;
+  let currentDurationMs = 0;
+  for (const bucket of hourlyReport.buckets) {
+    const quietMs = Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs);
+    const isQuietBucket = quietMs >= 30 * 60000;
+    if (isQuietBucket) {
+      currentStart ??= bucket.start;
+      currentDurationMs += quietMs;
+      continue;
+    }
+    if (currentStart && currentDurationMs > longestQuietRun.durationMs) {
+      longestQuietRun = {
+        durationMs: currentDurationMs,
+        start: currentStart
+      };
+    }
+    currentStart = null;
+    currentDurationMs = 0;
+  }
+  if (currentStart && currentDurationMs > longestQuietRun.durationMs) {
+    longestQuietRun = {
+      durationMs: currentDurationMs,
+      start: currentStart
+    };
+  }
+  if (longestQuietRun.durationMs > 0) {
+    return longestQuietRun;
+  }
+  const quietestBucket = hourlyReport.buckets.reduce((currentQuietest, bucket) => {
+    const quietMs = Math.max(0, bucket.end.getTime() - bucket.start.getTime() - bucket.directActivityMs - bucket.agentOnlyMs);
+    return quietMs > currentQuietest.durationMs ? { durationMs: quietMs, start: bucket.start } : currentQuietest;
+  }, longestQuietRun);
+  return quietestBucket;
+}
+function describeDayPeriod(timestamp, report) {
+  const hourOfDay = Number.parseInt(formatHourOfDay(timestamp, report.window), 10);
+  if (hourOfDay >= 21 || hourOfDay < 5) {
+    return "overnight";
+  }
+  if (hourOfDay < 12) {
+    return "this morning";
+  }
+  if (hourOfDay < 17) {
+    return "this afternoon";
+  }
+  return "this evening";
+}
 function formatDurationLabel(durationMs) {
   return `${Math.round(durationMs / 60000)}m`;
 }
@@ -1552,6 +2347,9 @@ function renderSnapshotRow(label, primaryText, detailText, role, options) {
 // 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
@@ -1569,12 +2367,15 @@ async function runLast24hCommand(command) {
     wakeWindow: command.wakeWindow,
     window
   });
-  return renderSummaryReport(summaryReport, createRenderOptions(command.shareMode), hourlyReport);
+  return renderSummaryReport(summaryReport, createRenderOptions(command.shareMode), hourlyReport, buildBestPlaque(bestMetrics.ledger));
 }
 
 // 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({
     windowStart: window.start,
     windowEnd: window.end
@@ -1585,7 +2386,7 @@ async function runTodayCommand(command) {
     idleCutoffMs: command.idleCutoffMs,
     wakeWindow: command.wakeWindow,
     window
-  }), createRenderOptions(command.shareMode));
+  }), createRenderOptions(command.shareMode), undefined, buildBestPlaque(bestMetrics.ledger));
 }
 
 // src/cli/run-idletime.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idletime",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Visual CLI for Codex focus, token burn, spikes, and idle time from local session logs.",
   "author": "ParkerRex",
   "main": "./dist/idletime.js",
@@ -44,12 +44,15 @@
   "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",
+    "check:release": "bun run build && bun run typecheck && bun test && bun run qa && npm pack --dry-run",
     "dev": "bun run src/cli/idletime-bin.ts",
     "idletime": "bun run src/cli/idletime-bin.ts",
-    "pack:dry-run": "npm pack --dry-run",
+    "pack:dry-run": "bun run build && npm pack --dry-run",
     "publish:dry-run": "bun run build && bun publish --dry-run --access public",
     "prepublishOnly": "bun run check:release",
+    "qa": "bun run qa:gaps && bun run qa:journeys",
+    "qa:gaps": "bun run qa/find-gaps.ts",
+    "qa:journeys": "bun run qa/run-shell-journeys.ts",
     "test": "bun test",
     "typecheck": "tsc --noEmit"
   },