@drakulavich/zapara 0.3.1 → 0.5.0

package/src/derive.ts

@@ -1,11 +1,14 @@
 import { score } from "./score.ts";
-import type { Day, Event, HourBucket, Metrics, Totals, Window } from "./types.ts";
+import type { Day, Event, EventKind, HourBucket, LiveBucket, Metrics, Totals, Window } from "./types.ts";
 
 export const LOOKBACK_MS = 3 * 60 * 60 * 1000;
 export const GAP_MS = 10 * 60 * 1000;
 export const SLOT_MS = 5 * 60 * 1000;
+const LIVE_MS = 60 * 60 * 1000;
 const LATE_HOURS = new Set([23, 0, 1, 2, 3, 4, 5]);
 
+// Not localeCompare: a result must not depend on the locale.
+export const compareStrings = (a: string, b: string): number => (a < b ? -1 : a > b ? 1 : 0);
 const pad2 = (n: number) => String(n).padStart(2, "0");
 export const localDate = (d: Date) => `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
 const parseDate = (s: string): Date => {
@@ -30,21 +33,65 @@ const emptyMetrics = (): Metrics => ({
   decisions: 0, contextSwitches: 0, activeMin: 0, streakMin: 0, lateNight: false,
 });
 
-type Acc = { m: Metrics; sessions: Set<string>; slots: Set<number>; lastPromptSession: string | null; lastPrompt: { ts: number; streakStart: number } | null };
+// Presence is the human's own actions only: agent records and the agent's asks
+// are never presence, because presence answers "is it time to rest?".
+const PRESENCE: ReadonlySet<EventKind> = new Set<EventKind>(["prompt", "interrupt", "reject", "answer"]);
 
-// Walks the sorted, look-back-filtered events once, keyed by "date|hour",
-// tracking the running presence streak (which may start before startMs) and
-// accumulating each bucket's raw counts.
-//
-// Presence is the human's: both the streak and the covered slots are built from
-// `prompt` events alone, because both answer "is it time to rest?". Agents that
-// work on while the human is away must not keep a streak alive or fill the day,
-// so `activity` is left with session liveness and nothing else.
-//
-// Prompts before startMs update presence only: they are never counted in a
-// bucket, and neither are the slots they cover before startMs, but a span from
-// such a prompt into the window still covers the window's first slots.
-function foldEvents(sorted: Event[], startMs: number): Map<string, Acc> {
+type Acc = { m: Metrics; sessions: Set<string>; slots: Set<number>; lastPromptSession: string | null; maxStreakMs: number; lastPresence: { ts: number; streakStart: number } | null };
+const newAcc = (): Acc => ({ m: emptyMetrics(), sessions: new Set(), slots: new Set(), lastPromptSession: null, maxStreakMs: 0, lastPresence: null });
+
+// Inside a streak the human sat through the gap, so a pair of actions covers
+// every slot between them; an action that starts a streak covers only its own.
+const coverage = (prevTs: number | null, streakStart: number, e: Event): { from: number; to: number; streakStart: number } => {
+  const to = Math.floor(e.ts / SLOT_MS);
+  if (prevTs !== null && e.ts - prevTs <= GAP_MS) return { from: Math.floor(prevTs / SLOT_MS), to, streakStart };
+  return { from: to, to, streakStart: e.ts };
+};
+
+// The counts an hour bucket and the live bucket share. `streakStart` is the
+// caller's: a streak may have begun before this accumulator's window. The streak
+// kept is the longest seen, not the one the window ended on, or a single prompt
+// after a break would erase the run.
+function accumulate(a: Acc, e: Event, streakStart: number): void {
+  if (PRESENCE.has(e.kind)) {
+    a.maxStreakMs = Math.max(a.maxStreakMs, e.ts - streakStart);
+    a.lastPresence = { ts: e.ts, streakStart }; // for the day's live streak
+  }
+  switch (e.kind) {
+    case "activity":
+      a.sessions.add(e.sessionId);
+      break;
+    case "prompt":
+      a.m.prompts++;
+      if (a.lastPromptSession !== null && a.lastPromptSession !== e.sessionId) a.m.contextSwitches++;
+      a.lastPromptSession = e.sessionId;
+      break;
+    case "report": a.m.reports++; break;
+    case "output": a.m.outputTokens += e.tokens ?? 0; break;
+    case "interrupt": a.m.interrupts++; break;
+    case "reject": a.m.rejects++; break;
+    case "question": a.m.questions++; break;
+    case "plan_review": a.m.plans++; break;
+    case "mode_change": a.m.modeSwitches++; break;
+  }
+}
+
+// `lateNight` is the caller's: an hour's own label, or the hour of `now` for the
+// live bucket. A fresh accumulator is an empty hour and scores null.
+function finish(a: Acc, lateNight: boolean): LiveBucket {
+  const m = a.m;
+  m.sessions = a.sessions.size;
+  m.activeMin = a.slots.size * 5;
+  m.streakMin = Math.round(a.maxStreakMs / 60000);
+  m.decisions = m.interrupts + m.rejects + m.questions + m.plans + m.modeSwitches;
+  m.lateNight = lateNight;
+  return { ...m, score: score(m) };
+}
+
+// The 24 hour buckets, keyed "date|hour". Events before startMs are look-back:
+// they move the streak but enter no bucket, though a span from one into the
+// window still covers the window's first slots.
+function foldEvents(sorted: Event[], startMs: number): { acc: Map<string, Acc>; carried: { ts: number; streakStart: number } | null } {
   const acc = new Map<string, Acc>(); // key "date|hour"
   const key = (ts: number): string => {
     const d = new Date(ts);
@@ -52,69 +99,62 @@ function foldEvents(sorted: Event[], startMs: number): Map<string, Acc> {
   };
   const get = (k: string): Acc => {
     let a = acc.get(k);
-    if (!a) { a = { m: emptyMetrics(), sessions: new Set(), slots: new Set(), lastPromptSession: null, lastPrompt: null }; acc.set(k, a); }
+    if (!a) { a = newAcc(); acc.set(k, a); }
     return a;
   };
 
-  let prevPromptTs: number | null = null;
-  let streakStart = 0; // always set by the first prompt, which starts a streak
+  let prevPresenceTs: number | null = null;
+  let streakStart = 0; // always set by the first presence event, which starts a streak
+  let carried: { ts: number; streakStart: number } | null = null;
   for (const e of sorted) {
-    if (e.kind === "prompt") {
-      const slot = Math.floor(e.ts / SLOT_MS);
-      // A prompt covers its own slot. Inside a streak the human sat through the
-      // gap too, so the pair also covers every slot between them; a prompt that
-      // starts a streak covers nothing behind it.
-      let from = slot;
-      if (prevPromptTs !== null && e.ts - prevPromptTs <= GAP_MS) from = Math.floor(prevPromptTs / SLOT_MS);
-      else streakStart = e.ts;
-      for (let s = from; s <= slot; s++) {
+    if (PRESENCE.has(e.kind)) {
+      const c = coverage(prevPresenceTs, streakStart, e);
+      streakStart = c.streakStart;
+      for (let s = c.from; s <= c.to; s++) {
         const slotStart = s * SLOT_MS;
         if (slotStart >= startMs) get(key(slotStart)).slots.add(s); // a slot belongs to the bucket of its start
       }
-      prevPromptTs = e.ts;
+      prevPresenceTs = e.ts;
+      // A person at the keyboard at 23:58 is still in that streak at 00:03,
+      // and the day they are looking at holds nothing yet.
+      if (e.ts < startMs) carried = { ts: e.ts, streakStart };
     }
     if (e.ts < startMs) continue; // look-back: presence bookkeeping only
-    const a = get(key(e.ts));
-    switch (e.kind) {
-      case "activity":
-        a.sessions.add(e.sessionId);
-        break;
-      case "prompt":
-        a.m.prompts++;
-        if (a.lastPromptSession !== null && a.lastPromptSession !== e.sessionId) a.m.contextSwitches++;
-        a.lastPromptSession = e.sessionId;
-        a.lastPrompt = { ts: e.ts, streakStart };
-        break;
-      case "report": a.m.reports++; break;
-      case "output": a.m.outputTokens += e.tokens ?? 0; break;
-      case "interrupt": a.m.interrupts++; break;
-      case "reject": a.m.rejects++; break;
-      case "question": a.m.questions++; break;
-      case "plan_review": a.m.plans++; break;
-      case "mode_change": a.m.modeSwitches++; break;
+    accumulate(get(key(e.ts)), e, streakStart);
+  }
+  return { acc, carried };
+}
+
+// The sixty minutes ending at `now`, by the rule an hour bucket uses. Presence
+// runs from the first event, so a streak older than the window is measured from
+// where it began. Events before the day's start count here, unlike in a bucket:
+// the window is a clock's hour, not a calendar's.
+function foldLive(sorted: Event[], nowMs: number): Acc {
+  const a = newAcc();
+  const fromMs = nowMs - LIVE_MS;
+  const inWindow = (t: number): boolean => t > fromMs && t <= nowMs;
+  let prevPresenceTs: number | null = null;
+  let streakStart = 0;
+  for (const e of sorted) {
+    if (PRESENCE.has(e.kind)) {
+      const c = coverage(prevPresenceTs, streakStart, e);
+      streakStart = c.streakStart;
+      for (let s = c.from; s <= c.to; s++) if (inWindow(s * SLOT_MS)) a.slots.add(s);
+      prevPresenceTs = e.ts;
     }
+    if (inWindow(e.ts)) accumulate(a, e, streakStart);
   }
-  return acc;
+  return a;
 }
 
-// Builds one Day's 24 hour buckets from the accumulated counts, scores each,
-// and rolls up totals, peak and mean.
 function buildDay(date: string, acc: Map<string, Acc>): Day {
   const buckets: HourBucket[] = [];
+  // Hours run in time order, so the last write is the day's last action.
+  let lastPresence: { ts: number; streakStart: number } | null = null;
   for (let hour = 0; hour < 24; hour++) {
     const a = acc.get(`${date}|${hour}`);
-    const m = a ? a.m : emptyMetrics();
-    if (a) {
-      m.sessions = a.sessions.size;
-      m.activeMin = a.slots.size * 5;
-      m.streakMin = a.lastPrompt ? Math.round((a.lastPrompt.ts - a.lastPrompt.streakStart) / 60000) : 0;
-    }
-    m.decisions = m.interrupts + m.rejects + m.questions + m.plans + m.modeSwitches;
-    // lateNight is a property of the hour label, so it is set on every bucket,
-    // including empty ones; score() returns null for buckets without
-    // sessions, so an empty late hour scores nothing.
-    m.lateNight = LATE_HOURS.has(hour);
-    buckets.push({ ...m, hour, score: score(m) });
+    if (a?.lastPresence) lastPresence = a.lastPresence;
+    buckets.push({ ...finish(a ?? newAcc(), LATE_HOURS.has(hour)), hour });
   }
   const scored = buckets.filter((b) => b.score !== null);
   const totals: Totals = buckets.reduce((t, b) => ({
@@ -129,6 +169,7 @@ function buildDay(date: string, acc: Map<string, Acc>): Day {
     peak: scored.length ? Math.max(...scored.map((b) => b.score!.index)) : null,
     mean: scored.length ? Math.round(scored.reduce((s, b) => s + b.score!.index, 0) / scored.length) : null,
     activeMin: buckets.reduce((s, b) => s + b.activeMin, 0),
+    presence: lastPresence && { lastAt: new Date(lastPresence.ts).toISOString(), streakStartAt: new Date(lastPresence.streakStart).toISOString() },
     totals,
     buckets,
   };
@@ -136,16 +177,25 @@ function buildDay(date: string, acc: Map<string, Acc>): Day {
 
 export function derive(events: Event[], w: Window): Day[] {
   const { startMs, endMs, cutoffMs, dates } = windowBounds(w);
+  // sort() is stable, so events equal on both keys keep their input order.
   const sorted = events
-    .map((e, i) => ({ e, i }))
-    .filter(({ e }) => e.ts >= cutoffMs && e.ts < endMs && (!w.now || e.ts <= w.now.getTime()))
-    .sort((a, b) => a.e.ts - b.e.ts || (a.e.sessionId < b.e.sessionId ? -1 : a.e.sessionId > b.e.sessionId ? 1 : 0) || a.i - b.i)
-    .map(({ e }) => e);
-  const acc = foldEvents(sorted, startMs);
+    .filter((e) => e.ts >= cutoffMs && e.ts < endMs && (!w.now || e.ts <= w.now.getTime()))
+    .sort((a, b) => a.ts - b.ts || compareStrings(a.sessionId, b.sessionId));
+  const { acc, carried } = foldEvents(sorted, startMs);
   const days = dates.map((date) => buildDay(date, acc));
+  // Only a first day with no action of its own borrows the look-back's streak,
+  // and only into `presence`: no bucket, total or active minute crosses back.
+  const first = days[0];
+  if (first && first.presence === null && carried) {
+    first.presence = { lastAt: new Date(carried.ts).toISOString(), streakStartAt: new Date(carried.streakStart).toISOString() };
+  }
   if (w.now) {
     const today = localDate(w.now);
-    for (const d of days) if (d.date === today) d.asOf = w.now.toISOString();
+    const open = days.find((d) => d.date === today);
+    if (open) {
+      open.asOf = w.now.toISOString();
+      open.live = finish(foldLive(sorted, w.now.getTime()), LATE_HOURS.has(w.now.getHours()));
+    }
   }
   return days;
 }

package/src/format.ts

@@ -1,8 +1,5 @@
-// Compact number formats shared by the card and the week footer. Pure: no
-// imports from node:/Bun, no clock, no file system.
-
-// Compact formats with a fixed longest form of five characters, so the layout
-// is sized once. Decimals are truncated, not rounded: 9.96M stays "9.9M".
+// Longest form is five characters, so the layout is sized once. Decimals are
+// truncated, not rounded: 9.96M stays "9.9M".
 function ladder(n: number): string {
   if (n >= 1e12) return "999B+";
   for (const [unit, size] of [["B", 1e9], ["M", 1e6], ["k", 1e3]] as const) {
@@ -16,5 +13,4 @@ function ladder(n: number): string {
 export const formatCount = (n: number): string => (n < 10_000 ? String(n) : ladder(n));
 export const formatTokens = (n: number): string => (n < 1000 ? String(n) : ladder(n));
 
-// "1 session", "5 sessions": a count with its noun, singular only for exactly one.
 export const plural = (n: number, one: string, many = `${one}s`, count = formatCount): string => `${count(n)} ${n === 1 ? one : many}`;

package/src/image.ts

@@ -1,14 +1,12 @@
-// The card's shell: the only module that reads the card assets, opens a
-// Bun.WebView or a Bun.Image, and writes a file. Everything it writes is the one
-// file the person named; nothing here prints.
+// The only module that reads the card assets, opens a Bun.WebView or Bun.Image,
+// and writes the card.
 import { readFile, writeFile } from "node:fs/promises";
 import type { CardAssets } from "./cardhtml.ts";
 
 const ASSETS = new URL("../assets/", import.meta.url);
 const FILES = ["fonts/inter-400.woff2", "fonts/inter-700.woff2", "fonts/inter-800.woff2", "fonts/jetbrains-mono-500.woff2", "characters.webp"] as const;
 
-// Reads the five files next to the source. A missing, unreadable or empty one is
-// a broken install, reported without a path: the CLI never prints one.
+// A missing or empty asset is a broken install, reported without a path.
 export async function loadAssets(): Promise<CardAssets> {
   let parts: string[];
   try {
@@ -23,21 +21,18 @@ export async function loadAssets(): Promise<CardAssets> {
 
 const BACKEND = process.platform === "darwin" ? "webkit" : "chrome";
 const ENGINE_LINE = "card needs a browser engine: install Google Chrome, or write --out card.html";
+const WRITE_LINE = "cannot write the card: check the --out directory";
 const WIDTH = 2400;
 const HEIGHT = 1260;
 const READY = 'document.fonts.ready.then(() => document.fonts.status === "loaded" && Array.from(document.images).every((i) => i.complete))';
 
-// Writes the page as is for `.html`; otherwise photographs it at 2400x1260 and
-// writes PNG or WebP. The 15s budget bounds the whole render (construct, navigate,
-// poll, screenshot, resize, encode), raced against a single timer; the view is
-// closed on every path. Any engine failure (constructor, navigate, evaluate,
-// screenshot) is mapped to one line that never quotes the engine's own text; the
-// timeout error passes through unchanged. `writeFile` failures are the one
-// exception, left unmapped, so they keep reporting the user's own `--out` string.
+// The budget bounds the whole render, raced against one timer; the view is
+// closed on every path. An engine failure becomes one line that never quotes
+// the engine's text; the timeout error passes through unchanged.
 export async function renderCard(html: string, out: string, timeoutMs = 15_000): Promise<void> {
   const lower = out.toLowerCase();
   if (lower.endsWith(".html")) {
-    await writeFile(out, html);
+    await write(out, html);
     return;
   }
   let bytes: Uint8Array;
@@ -66,5 +61,14 @@ export async function renderCard(html: string, out: string, timeoutMs = 15_000):
   } finally {
     clearTimeout(timer!);
   }
-  await writeFile(out, bytes);
+  await write(out, bytes);
+}
+
+// One line for every failure: node's error quotes the path, and the CLI never prints one.
+async function write(out: string, data: string | Uint8Array): Promise<void> {
+  try {
+    await writeFile(out, data);
+  } catch {
+    throw new Error(WRITE_LINE);
+  }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-// zapara CLI. Argument parsing, the clock, stdout and exit codes live here; everything else is pure.
+// Argument parsing, the clock, stdout and exit codes live here; everything else is pure.
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -13,9 +13,8 @@ import { renderStatus, statusOf } from "./status.ts";
 import { writeStatus } from "./statusfile.ts";
 import type { Day } from "./types.ts";
 
-// Read lazily, only when --version is actually handled, so a broken install
-// (missing or corrupt package.json) fails inside the guarded catch below
-// instead of throwing at module load, before any try/catch is in place.
+// Read only when --version is handled, so a broken package.json fails inside
+// the guarded catch instead of at module load.
 function version(): string {
   const parsed: unknown = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
   if (typeof parsed === "object" && parsed !== null && typeof (parsed as { version?: unknown }).version === "string") {
@@ -45,22 +44,18 @@ options:
 levels: calm 0-29  warming 30-59  heating 60-84  fried 85-100`;
 const HINT = "run 'zapara --help' for usage";
 
-// A grid is the window as one cell per hour; a day is one date as one row per
-// hour; status is today, written to the status file for a status line to read.
 type Args = { command: "grid" | "day" | "card" | "status"; to: string; days: number; explain: boolean; json: boolean; out: string; projects: string; color: boolean };
 
 class UsageError extends Error {}
-// Thrown only at a flag position (never when a token was consumed as another
-// flag's value, e.g. `--to --help`), so `main()` can short-circuit to exit 0
-// without parseArgs having to also validate the rest of a help/version call.
+// Thrown only at a flag position, never for a token consumed as another flag's
+// value (`--to --help`).
 class HelpRequested extends Error {}
 class VersionRequested extends Error {}
 
 const DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
 
-// A usage error quotes the offending value only when it is short, printable ASCII
-// with no path separator: the CLI never prints a filesystem path or an escape,
-// not even one the person typed.
+// A usage error quotes the value only when it is short, printable ASCII with no
+// path separator: the CLI never prints a path or an escape, even one typed in.
 const quotable = (v: string): boolean => /^[\x21-\x7e]{1,24}$/.test(v) && !/[\/\\]/.test(v);
 const got = (v: string): string => (quotable(v) ? `, got ${v}` : "");
 const named = (v: string): string => (quotable(v) ? ` ${v}` : "");
@@ -73,7 +68,6 @@ function validDate(s: string): boolean {
   return dt.getFullYear() === y && dt.getMonth() === mo - 1 && dt.getDate() === d;
 }
 
-// A date on the command line: YYYY-MM-DD, today or yesterday, in local time.
 function resolveDate(what: string, s: string, now: Date): string {
   if (s === "today") return localDate(now);
   if (s === "yesterday") return localDate(new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1));
@@ -81,15 +75,13 @@ function resolveDate(what: string, s: string, now: Date): string {
   return s;
 }
 
-// Calendar days from one date to another, inclusive; UTC arithmetic so a DST day is still one day.
+// UTC arithmetic, so a DST day is still one day.
 function spanDays(from: string, to: string): number {
   const utc = (s: string): number => { const [y = 0, m = 0, d = 0] = s.split("-").map(Number); return Date.UTC(y, m - 1, d); };
   return Math.round((utc(to) - utc(from)) / 86_400_000) + 1;
 }
 
-// The window from its flags: --days ending today or at --to, or --from/--to, both
-// inclusive. --from with --days is one length too many. Checks run in the order
-// a reader meets the flags in --help.
+// Checks run in the order a reader meets the flags in --help.
 function windowOf(days: string | null, from: string | null, to: string | null, defaultDays: number, now: Date): { to: string; days: number } {
   if (from !== null && days !== null) throw new UsageError("--from sets the length; drop --days");
   if (days !== null && (!/^\d+$/.test(days) || Number(days) < 1 || Number(days) > 90)) throw new UsageError(`--days must be 1..90${got(days)}`);
@@ -110,19 +102,16 @@ function parseArgs(argv: string[], now: Date, env: NodeJS.ProcessEnv, isTTY: boo
   let jsonFlag = false;
   let outGiven = false;
   const positional: string[] = [];
-  // A value flag given twice is a usage error, not the last value winning
-  // silently; bare flags (--json, --explain, --no-color) are idempotent and stay untracked.
+  // A value flag given twice is a usage error; bare flags are idempotent and untracked.
   const seen = new Set<string>();
   for (let i = 0; i < argv.length; i++) {
     let arg = argv[i]!;
-    // `--days=30` is `--days 30`. A flag that takes no value refuses an inline one.
     let inline: string | null = null;
     const eq = arg.startsWith("--") ? arg.indexOf("=") : -1;
     if (eq > 0) { inline = arg.slice(eq + 1); arg = arg.slice(0, eq); }
     const bare = (): void => { if (inline !== null) throw new UsageError(`unknown flag${named(argv[i]!)}`); };
-    // A missing value or one that looks like another flag is a usage error,
-    // never treated as this flag's value (e.g. `--projects --json`). Only --days
-    // takes a negative number as a value, so `--days -1` reaches the range check.
+    // A value that looks like another flag is a usage error (`--projects --json`);
+    // only --days accepts a negative number, so `--days -1` reaches the range check.
     const value = (negativeNumberIsValue = false): string => {
       let v: string;
       if (inline !== null) v = inline;
@@ -161,19 +150,16 @@ function parseArgs(argv: string[], now: Date, env: NodeJS.ProcessEnv, isTTY: boo
   else if (word === "today" || word === "yesterday" || DATE.test(word)) { a.command = "day"; a.to = resolveDate("date", word, now); a.days = 1; }
   else throw new UsageError(`unknown command${named(word)} (try today, yesterday, a date, card or status)`);
 
-  // Both commands fix their own window: a named day is the date given, status is today.
   if (a.command === "day" || a.command === "status") {
     if (days !== null || from !== null || to !== null) throw new UsageError(`--days, --from and --to do not apply to ${a.command === "day" ? "a named day" : "status"}`);
   } else {
-    // Two weeks make a pattern; a week makes a picture of one week.
     ({ to: a.to, days: a.days } = windowOf(days, from, to, a.command === "card" ? 14 : 7, now));
   }
-  // Tables turn into JSON in a pipe; the card is a file either way, so only an explicit --json switches it.
+  // The card is a file either way, so only an explicit --json switches it.
   a.json = a.command === "card" ? jsonFlag : jsonFlag || !isTTY;
   if (a.command !== "day" && a.explain) throw new UsageError("--explain applies to a named day only");
   if (a.command !== "card" && outGiven) throw new UsageError("--out applies to card only");
-  // The value is printed back verbatim in `wrote \u2026`, so it must be one plain line:
-  // no control character, and the message never quotes it.
+  // Printed back verbatim in `wrote \u2026`, so it must be one plain line.
   if (/[\x00-\x1f\x7f]/.test(a.out)) throw new UsageError("--out must not contain control characters");
   if (!/\.(png|webp|html)$/i.test(a.out)) throw new UsageError("--out must end in .png, .webp or .html");
   return a;
@@ -193,9 +179,7 @@ async function main(): Promise<number> {
   return 0;
 }
 
-// Today's load, written to the status file and then printed. The write comes
-// first so that a run whose write failed prints its one-line error and nothing
-// else: a caller never reads a line that was not saved for the status line.
+// The write comes first: a caller never reads a line that was not saved.
 async function status(a: Args, now: Date): Promise<number> {
   const days: Day[] = await report({ projects: a.projects, to: a.to, days: a.days, now });
   const line = renderStatus(statusOf(days[0]!, now));

package/src/parse.ts

@@ -5,9 +5,8 @@ const INTERRUPT_PREFIX = "[Request interrupted by user";
 const REJECT_PREFIX = "The user doesn't want to proceed with this tool use";
 const QUESTION_TOOL = "AskUserQuestion";
 const PLAN_TOOL = "ExitPlanMode";
-// Inbound messages from subagents, other sessions and background tasks: the human
-// has to read and react to these, but did not type them, so they are `report`
-// events, never `prompt`. An interrupt marker is checked first and always wins.
+// Inbound agent messages: read and reacted to, but not typed, so `report`, never
+// `prompt`. An interrupt marker is checked first and wins.
 const AGENT_MARKERS = [
   "Another Claude session sent a message:",
   "<teammate-message",
@@ -20,9 +19,12 @@ type Rec = Record<string, unknown>;
 const isObj = (v: unknown): v is Rec => typeof v === "object" && v !== null;
 const str = (v: unknown): string | null => (typeof v === "string" ? v : null);
 
+// A pasted screenshot puts an `image` block before the typed text, so the text
+// block is searched for, not taken from content[0].
 const firstText = (content: unknown): string | null => {
   if (typeof content === "string") return content;
-  if (Array.isArray(content) && isObj(content[0]) && content[0].type === "text") return str(content[0].text);
+  if (!Array.isArray(content)) return null;
+  for (const b of content) if (isObj(b) && b.type === "text") return str(b.text);
   return null;
 };
 
@@ -30,10 +32,13 @@ export function parseTranscript(text: string): Event[] {
   const events: Event[] = [];
   let lastTs: number | null = null;
   let lastMode: string | null = null;
-  // Dedupes `output` events by requestId within this one file: Claude Code
-  // writes one record per content block of a response, repeating the same
-  // requestId and usage, so only the first qualifying record counts.
+  let pendingModeChanges = 0;
+  // Claude Code writes one record per content block of a response, repeating
+  // the requestId and usage; only the first qualifying record counts.
   const seenRequestIds = new Set<string>();
+  // Ids of the two tools whose result the human writes; every other
+  // `tool_result` is the machine reporting back.
+  const askedIds = new Set<string>();
 
   for (const line of text.split("\n")) {
     if (line.trim() === "") continue;
@@ -48,12 +53,11 @@ export function parseTranscript(text: string): Event[] {
     if (type === "permission-mode") {
       const m = str(rec.permissionMode);
       if (m === null) continue;
-      // The baseline mode is tracked as soon as it is seen, even before any
-      // timestamp exists, so a later switch away from it can be detected. A
-      // switch is only ever emitted as an event once a timestamp is known;
-      // a switch that happens before any timestamp is known is dropped.
-      if (lastMode !== null && m !== lastMode && lastTs !== null) {
-        events.push({ ts: lastTs, sessionId, kind: "mode_change" });
+      // A switch before the first timestamped record is how a session often
+      // starts; it waits and is attributed to that record.
+      if (lastMode !== null && m !== lastMode) {
+        if (lastTs === null) pendingModeChanges++;
+        else events.push({ ts: lastTs, sessionId, kind: "mode_change" });
       }
       lastMode = m;
       continue;
@@ -64,6 +68,7 @@ export function parseTranscript(text: string): Event[] {
     if (Number.isNaN(ts)) continue;
     lastTs = ts;
     events.push({ ts, sessionId, kind: "activity" });
+    for (; pendingModeChanges > 0; pendingModeChanges--) events.push({ ts, sessionId, kind: "mode_change" });
 
     const content = isObj(rec.message) ? rec.message.content : undefined;
     if (type === "user") {
@@ -72,6 +77,8 @@ export function parseTranscript(text: string): Event[] {
         if (!isObj(b) || b.type !== "tool_result") continue;
         const t = firstText(b.content);
         if (t !== null && t.startsWith(REJECT_PREFIX)) events.push({ ts, sessionId, kind: "reject" });
+        const toolUseId = str(b.tool_use_id);
+        if (toolUseId !== null && askedIds.has(toolUseId)) events.push({ ts, sessionId, kind: "answer" });
       }
       const head = firstText(content);
       if (head === null) continue;
@@ -84,20 +91,22 @@ export function parseTranscript(text: string): Event[] {
       const blocks = Array.isArray(content) ? content : [];
       for (const b of blocks) {
         if (!isObj(b) || b.type !== "tool_use") continue;
-        if (b.name === QUESTION_TOOL) events.push({ ts, sessionId, kind: "question" });
-        else if (b.name === PLAN_TOOL) events.push({ ts, sessionId, kind: "plan_review" });
+        if (b.name !== QUESTION_TOOL && b.name !== PLAN_TOOL) continue;
+        events.push({ ts, sessionId, kind: b.name === QUESTION_TOOL ? "question" : "plan_review" });
+        const id = str(b.id);
+        if (id !== null) askedIds.add(id);
       }
-      // `output`: one event per distinct requestId per file, the first record seen
-      // that has a string requestId, numeric usage.output_tokens and at least one
-      // text block. A response holding only tool_use blocks is not text the human
-      // reads, so it never triggers this, even on its first (and only) record.
+      // A response of only tool_use blocks is not text the human reads and carries
+      // no output tokens. A count must be a finite non-negative integer: `1e309`
+      // parses to Infinity, and a day once summed to NaN.
       const requestId = str(rec.requestId);
       const usage = isObj(rec.message) ? rec.message.usage : undefined;
       const outputTokens = isObj(usage) ? usage.output_tokens : undefined;
+      const tokens = typeof outputTokens === "number" && Number.isSafeInteger(outputTokens) && outputTokens >= 0 ? outputTokens : null;
       const hasText = blocks.some((b) => isObj(b) && b.type === "text");
-      if (requestId !== null && typeof outputTokens === "number" && hasText && !seenRequestIds.has(requestId)) {
+      if (requestId !== null && tokens !== null && hasText && !seenRequestIds.has(requestId)) {
         seenRequestIds.add(requestId);
-        events.push({ ts, sessionId, kind: "output", tokens: outputTokens });
+        events.push({ ts, sessionId, kind: "output", tokens });
       }
     }
   }