hacklab 0.19.0 → 0.21.0

package/dist/prompt-stats.d.ts

@@ -1,15 +1,61 @@
 /** Buckets are `1..bucketMax`, so the axis stays readable at any prompt length. */
 export declare const PROMPT_LENGTH_BUCKET_MIN = 10;
 export declare const PROMPT_LENGTH_BUCKET_MAX = 100;
-/** The percentile that sets `bucketMax`; everything above lands in the overflow. */
-export declare const PROMPT_LENGTH_OVERFLOW_PERCENTILE = 0.9;
+/** The percentile that sets `bucketMax`; everything above it lands in `tail`. */
+export declare const PROMPT_LENGTH_AXIS_PERCENTILE = 0.9;
+/** The server's cap on `tail` entries; longer distributions are coarsened. */
+export declare const PROMPT_TAIL_MAX_ENTRIES = 400;
 /** Matches the backend's cap — anything longer is truncated before upload. */
 export declare const CONVERSATION_SAMPLE_MAX_CHARS = 20000;
+/**
+ * Which definition of "a prompt the user typed" produced this upload.
+ *
+ * Version 1 is implicit — every CLI shipped before this field existed counted
+ * harness-generated `user` entries (subagent task notifications, skill bodies,
+ * slash-command echoes, interrupt markers) as prompts, which inflated the
+ * counts and blew out the word tallies. Version 2 is the scan with
+ * `isHarnessNoise` in it.
+ *
+ * It rides on every sync as a top-level `scannerVersion`; the server ignores
+ * `promptStats` / `promptActivity` from anything below 2, so an un-upgraded CLI
+ * can't keep writing the old numbers into a table that was wiped to fix them.
+ */
+export declare const PROMPT_SCANNER_VERSION = 2;
+/**
+ * Is this entry text something the harness wrote rather than the user?
+ *
+ * Deliberately a prefix test and nothing more — no stripping of inline
+ * `<system-reminder>` blocks out of otherwise-typed prompts. Those measured at
+ * zero words of real contribution, and rewriting prompt text in place is a
+ * bigger risk than the noise it would remove.
+ */
+export declare function isHarnessNoise(text: string): boolean;
 export type PromptStatsProject = {
     repoUrl: string;
     promptCount: number;
     lastActiveAt: string;
 };
+/** One session's running aggregate, as both the tick and a full scan build it. */
+export type PromptSessionAggregate = {
+    /** ISO timestamp of the first prompt seen in this session. */
+    startedAt: string;
+    /** ISO timestamp of the most recent one. */
+    lastActiveAt: string;
+    promptCount: number;
+};
+/** One day's running tally. Cumulative for this machine, never a delta. */
+export type PromptDayAggregate = {
+    prompts: number;
+    words: number;
+};
+/**
+ * The whole prompt-activity aggregate, keyed for cheap merging: sessions by
+ * session id, days by YYYY-MM-DD.
+ */
+export type PromptActivityAggregate = {
+    sessions: Record<string, PromptSessionAggregate>;
+    daily: Record<string, PromptDayAggregate>;
+};
 export type PromptStats = {
     totalPrompts: number;
     bucketMax: number;
@@ -17,7 +63,27 @@ export type PromptStats = {
         length: number;
         count: number;
     }[];
+    /**
+     * The exact distribution above `bucketMax`, and the only place those prompts
+     * are reported — the histogram stops at `bucketMax`. One entry per distinct
+     * word count, ascending, coarsened if there are more than
+     * `PROMPT_TAIL_MAX_ENTRIES` of them. Always present, empty when nothing
+     * exceeds `bucketMax`: the field's presence is what tells the server this
+     * histogram is exact, as opposed to a legacy snapshot whose last bar lumped
+     * everything at or above `bucketMax`.
+     */
+    tail: {
+        length: number;
+        count: number;
+    }[];
     projects: PromptStatsProject[];
+    /**
+     * Sessions and per-day counts for the whole local history. Not part of the
+     * `promptStats` block on the wire — the caller hands it to `stageFullScan`,
+     * which re-bases the tick's incremental state on it and works out which rows
+     * this upload still has to carry.
+     */
+    activity: PromptActivityAggregate;
     /** Only ever set under the `full` consent tier. */
     conversationSample?: string;
 };
@@ -30,13 +96,57 @@ export type PromptStats = {
  * blocks, so a line only counts when its content is a plain string or an array
  * of nothing but `text` blocks. Sidechain entries (subagent conversations) are
  * the agent talking to itself, not the person typing, so they're excluded.
+ *
+ * That still leaves the harness's own writing, which is indistinguishable by
+ * shape: subagent reports, injected skill bodies, slash-command echoes,
+ * interrupt markers. Those are dropped two ways — `isMeta`, which Claude Code
+ * sets on the entries it generates, and the text prefixes in
+ * `isHarnessNoise` for the ones it doesn't.
+ *
+ * This is the single chokepoint: both the full scan and the minutely tick go
+ * through here, so the histogram, the tail, the per-project counts, the
+ * activity aggregate and the technical-score sample all see the same prompts.
  */
 export declare function promptTextFrom(entry: unknown): string | null;
 /** Whitespace-separated word count. Zero-word prompts are dropped by callers. */
 export declare function countWords(text: string): number;
+/** The server's cap on a session id. Longer than this and the row is rejected. */
+export declare const PROMPT_SESSION_ID_MAX_CHARS = 128;
+/** One prompt, reduced to the three facts the activity aggregate needs. */
+export type PromptLine = {
+    sessionId: string;
+    /** Canonical ISO-8601 UTC, so string order is time order. */
+    timestamp: string;
+    words: number;
+};
+/**
+ * A transcript line as prompt activity, or null when it isn't one.
+ *
+ * Stricter than `promptTextFrom` on purpose: a prompt with no session id or no
+ * usable timestamp can't be placed on a session or a day, and the server's
+ * schema would reject it, so it counts towards the histogram (which needs
+ * neither) and nothing else.
+ */
+export declare function parsePromptLine(line: string): PromptLine | null;
+/** An ISO-8601 UTC string, or null when the value isn't a usable instant. */
+export declare function normalizeTimestamp(value: unknown): string | null;
+export declare function emptyPromptActivity(): PromptActivityAggregate;
+/**
+ * Fold one prompt into an activity aggregate, returning the session and date it
+ * landed on so an incremental caller can mark exactly those dirty.
+ *
+ * The date is the UTC day of the timestamp — the same attribution
+ * `toDateStr` gives every token daily row, so the two halves of a sync agree
+ * about which day a piece of work belongs to.
+ */
+export declare function addPromptToActivity(activity: PromptActivityAggregate, line: PromptLine): {
+    sessionId: string;
+    date: string;
+};
 /**
- * The overflow threshold for this user's own distribution: their p90 prompt
- * length rounded up to a multiple of 10, clamped to [10, 100].
+ * Where the histogram's axis ends for this user's own distribution: their p90
+ * prompt length rounded up to a multiple of 10, clamped to [10, 100]. Anything
+ * longer is reported by `buildTail` instead.
  *
  * Per-user rather than fixed because prompt length varies enormously between
  * people — a fixed axis would either crush a terse user's histogram into the
@@ -44,14 +154,40 @@ export declare function countWords(text: string): number;
  */
 export declare function bucketMaxFor(wordCounts: number[]): number;
 /**
- * Bucket the word counts. Buckets `1..bucketMax-1` are exact word counts; the
- * bucket at `bucketMax` is the overflow, holding every prompt that long or
- * longer. Empty buckets are omitted — the chart fills the gaps.
+ * Bucket the word counts. Every bucket `1..bucketMax` is an exact word count —
+ * there is no overflow bar. Empty buckets are omitted; the chart fills the gaps.
+ *
+ * Prompts longer than `bucketMax` are not in here at all: they are reported by
+ * `buildTail`, and only there. So the histogram and the tail partition the
+ * scan — sum(histogram counts) + sum(tail counts) === totalPrompts, always.
  */
 export declare function buildHistogram(wordCounts: number[], bucketMax: number): {
     length: number;
     count: number;
 }[];
+/**
+ * The exact distribution of everything *longer* than `bucketMax`, which the
+ * histogram does not cover at all. One entry per distinct word count,
+ * ascending; empty (never absent) when nothing exceeds `bucketMax` — the
+ * field's presence on the wire is the marker that the histogram's bars are
+ * exact.
+ *
+ * Lengths only — no prompt text is involved here, or anywhere near it.
+ *
+ * A machine with a long history can have thousands of distinct long lengths,
+ * far past what the server accepts, so an over-cap tail is coarsened: lengths
+ * are rounded to multiples of 2, then 4, 8, … until at most
+ * `PROMPT_TAIL_MAX_ENTRIES` entries remain, summing the counts that collapse
+ * together. Rounding is *up* so that a coarsened entry still sits above
+ * `bucketMax` — rounding down could claim a length inside the histogram's own
+ * exact range for a prompt the histogram never counted.
+ *
+ * Deterministic: the result depends only on the multiset of word counts.
+ */
+export declare function buildTail(wordCounts: number[], bucketMax: number): {
+    length: number;
+    count: number;
+}[];
 /**
  * The `origin` remote of the repo at `cwd`, or null when there isn't one (not
  * a repo, no origin, no git binary, or the directory is gone). The URL is sent
@@ -69,4 +205,10 @@ export declare function gitOriginUrl(cwd: string): Promise<string | null>;
 export declare function scanPromptStats(options?: {
     includeSample?: boolean;
 }): Promise<PromptStats | null>;
+/**
+ * The `promptStats` block as the server takes it. `activity` is deliberately
+ * dropped: it is local bookkeeping for the tick's incremental state, and it
+ * travels under its own top-level `promptActivity` field instead.
+ */
+export declare function promptStatsPayload(stats: PromptStats): Omit<PromptStats, 'activity'>;
 //# sourceMappingURL=prompt-stats.d.ts.map

package/dist/prompt-stats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-stats.d.ts","sourceRoot":"","sources":["../src/prompt-stats.ts"],"names":[],"mappings":"AA6BA,mFAAmF;AACnF,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAC1C,eAAO,MAAM,wBAAwB,MAAM,CAAA;AAC3C,oFAAoF;AACpF,eAAO,MAAM,iCAAiC,MAAM,CAAA;AACpD,8EAA8E;AAC9E,eAAO,MAAM,6BAA6B,QAAS,CAAA;AAEnD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC9C,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B,mDAAmD;IACnD,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAwB5D;AAED,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG/C;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAazD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,EAAE,MAAM,GAChB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAUrC;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAYtE;AAQD;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAoF7B"}
+{"version":3,"file":"prompt-stats.d.ts","sourceRoot":"","sources":["../src/prompt-stats.ts"],"names":[],"mappings":"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"}

package/dist/prompt-stats.js

@@ -1,18 +1,24 @@
 import { execFile } from 'node:child_process';
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
-import { findFiles } from './scanners/util.js';
+import { findFiles, toDateStr } from './scanners/util.js';
 /**
  * Prompt statistics, computed entirely on this machine from the local Claude
  * Code transcripts and uploaded only under an explicit consent tier (see
  * prompt-consent.ts).
  *
- * Two numbers come out of a scan:
+ * Three things come out of a full scan:
  *
- *   - a histogram of how long the user's own prompts are, in words
+ *   - a histogram of how long the user's own prompts are, in words — every
+ *     bucket an exact word count — plus the tail, which is where the prompts
+ *     longer than the axis are reported, and their only home
  *   - a per-project prompt count, keyed by the project's git origin
+ *   - the prompt *activity* aggregate: per-session start/end/count and a
+ *     per-day prompt/word tally. That one is also what the minutely tick
+ *     accumulates incrementally (scanners/incremental.ts), so a full scan can
+ *     re-base the tick's state without either drifting from the other.
  *
  * and, under the `full` tier only, a sample of the raw prompt text so the
  * backend can score "how technical is this person's prompting". The backend
@@ -26,10 +32,76 @@ const execFileAsync = promisify(execFile);
 /** Buckets are `1..bucketMax`, so the axis stays readable at any prompt length. */
 export const PROMPT_LENGTH_BUCKET_MIN = 10;
 export const PROMPT_LENGTH_BUCKET_MAX = 100;
-/** The percentile that sets `bucketMax`; everything above lands in the overflow. */
-export const PROMPT_LENGTH_OVERFLOW_PERCENTILE = 0.9;
+/** The percentile that sets `bucketMax`; everything above it lands in `tail`. */
+export const PROMPT_LENGTH_AXIS_PERCENTILE = 0.9;
+/** The server's cap on `tail` entries; longer distributions are coarsened. */
+export const PROMPT_TAIL_MAX_ENTRIES = 400;
 /** Matches the backend's cap — anything longer is truncated before upload. */
 export const CONVERSATION_SAMPLE_MAX_CHARS = 20_000;
+/**
+ * Which definition of "a prompt the user typed" produced this upload.
+ *
+ * Version 1 is implicit — every CLI shipped before this field existed counted
+ * harness-generated `user` entries (subagent task notifications, skill bodies,
+ * slash-command echoes, interrupt markers) as prompts, which inflated the
+ * counts and blew out the word tallies. Version 2 is the scan with
+ * `isHarnessNoise` in it.
+ *
+ * It rides on every sync as a top-level `scannerVersion`; the server ignores
+ * `promptStats` / `promptActivity` from anything below 2, so an un-upgraded CLI
+ * can't keep writing the old numbers into a table that was wiped to fix them.
+ */
+export const PROMPT_SCANNER_VERSION = 2;
+/**
+ * Prefixes that mark a `user` transcript entry as written by Claude Code
+ * itself rather than typed by the person at the keyboard.
+ *
+ * These all arrive in exactly the shape a real prompt does — `type: 'user'`,
+ * not a sidechain, content a plain string or `text` blocks — so nothing but the
+ * text tells them apart. Measured over 194 local transcripts they were 39% of
+ * everything the scan called a prompt and 65% of its words, because a machine's
+ * report or an injected skill body is an order of magnitude longer than
+ * anything a human types.
+ *
+ * Matched against the entry's text after `trimStart()`, and anchored to the
+ * start on purpose: a prompt that *quotes* one of these tags mid-sentence
+ * ("why does <command-name> show up twice?") is a real prompt and still counts.
+ */
+const HARNESS_NOISE_PREFIXES = [
+    // The body of a skill, injected when one is invoked. Up to ~11.5k words.
+    'Base directory for this skill:',
+    // A background subagent's report, handed back as a user turn: ~400 words
+    // each and the single largest source of fake prompts.
+    '<task-notification>',
+    // The wrapper around a slash command's expansion, its echo and its output.
+    '<local-command-caveat>',
+    '<command-name>',
+    '<command-message>',
+    '<command-args>',
+    '<local-command-stdout>',
+    // Context the harness injects into a turn. Nobody types it.
+    '<system-reminder>',
+    // Written when the user hits escape — the absence of a prompt, not one.
+    '[Request interrupted',
+    // `!`-prefixed bash mode: the command and whatever it printed.
+    '<bash-input>',
+    '<bash-stdout>',
+    '<bash-stderr>',
+    // Text a UserPromptSubmit hook appended to the turn.
+    '<user-prompt-submit-hook>',
+];
+/**
+ * Is this entry text something the harness wrote rather than the user?
+ *
+ * Deliberately a prefix test and nothing more — no stripping of inline
+ * `<system-reminder>` blocks out of otherwise-typed prompts. Those measured at
+ * zero words of real contribution, and rewriting prompt text in place is a
+ * bigger risk than the noise it would remove.
+ */
+export function isHarnessNoise(text) {
+    const start = text.trimStart();
+    return HARNESS_NOISE_PREFIXES.some((prefix) => start.startsWith(prefix));
+}
 /**
  * The user's own prompt text from one transcript line, or null when the line
  * isn't one.
@@ -39,6 +111,16 @@ export const CONVERSATION_SAMPLE_MAX_CHARS = 20_000;
  * blocks, so a line only counts when its content is a plain string or an array
  * of nothing but `text` blocks. Sidechain entries (subagent conversations) are
  * the agent talking to itself, not the person typing, so they're excluded.
+ *
+ * That still leaves the harness's own writing, which is indistinguishable by
+ * shape: subagent reports, injected skill bodies, slash-command echoes,
+ * interrupt markers. Those are dropped two ways — `isMeta`, which Claude Code
+ * sets on the entries it generates, and the text prefixes in
+ * `isHarnessNoise` for the ones it doesn't.
+ *
+ * This is the single chokepoint: both the full scan and the minutely tick go
+ * through here, so the histogram, the tail, the per-project counts, the
+ * activity aggregate and the technical-score sample all see the same prompts.
  */
 export function promptTextFrom(entry) {
     if (!entry || typeof entry !== 'object')
@@ -48,9 +130,12 @@ export function promptTextFrom(entry) {
         return null;
     if (line.isSidechain === true)
         return null;
+    if (line.isMeta === true)
+        return null;
     const content = line.message?.content;
-    if (typeof content === 'string')
-        return content;
+    if (typeof content === 'string') {
+        return isHarnessNoise(content) ? null : content;
+    }
     if (!Array.isArray(content))
         return null;
     const texts = [];
@@ -64,16 +149,103 @@ export function promptTextFrom(entry) {
             return null;
         texts.push(text);
     }
-    return texts.length > 0 ? texts.join('\n') : null;
+    if (texts.length === 0)
+        return null;
+    const joined = texts.join('\n');
+    return isHarnessNoise(joined) ? null : joined;
 }
 /** Whitespace-separated word count. Zero-word prompts are dropped by callers. */
 export function countWords(text) {
     const matches = text.match(/\S+/g);
     return matches ? matches.length : 0;
 }
+/** The server's cap on a session id. Longer than this and the row is rejected. */
+export const PROMPT_SESSION_ID_MAX_CHARS = 128;
+/**
+ * A transcript line as prompt activity, or null when it isn't one.
+ *
+ * Stricter than `promptTextFrom` on purpose: a prompt with no session id or no
+ * usable timestamp can't be placed on a session or a day, and the server's
+ * schema would reject it, so it counts towards the histogram (which needs
+ * neither) and nothing else.
+ */
+export function parsePromptLine(line) {
+    if (!line.trim())
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const text = promptTextFrom(parsed);
+    if (text === null)
+        return null;
+    const words = countWords(text);
+    if (words <= 0)
+        return null;
+    const entry = parsed;
+    const sessionId = typeof entry.sessionId === 'string' ? entry.sessionId.trim() : '';
+    if (!sessionId || sessionId.length > PROMPT_SESSION_ID_MAX_CHARS)
+        return null;
+    const timestamp = normalizeTimestamp(entry.timestamp);
+    if (!timestamp)
+        return null;
+    return { sessionId, timestamp, words };
+}
+/** An ISO-8601 UTC string, or null when the value isn't a usable instant. */
+export function normalizeTimestamp(value) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return null;
+    const at = typeof value === 'number' ? value : Date.parse(value);
+    if (!Number.isFinite(at))
+        return null;
+    return new Date(at).toISOString();
+}
+export function emptyPromptActivity() {
+    return { sessions: {}, daily: {} };
+}
 /**
- * The overflow threshold for this user's own distribution: their p90 prompt
- * length rounded up to a multiple of 10, clamped to [10, 100].
+ * Fold one prompt into an activity aggregate, returning the session and date it
+ * landed on so an incremental caller can mark exactly those dirty.
+ *
+ * The date is the UTC day of the timestamp — the same attribution
+ * `toDateStr` gives every token daily row, so the two halves of a sync agree
+ * about which day a piece of work belongs to.
+ */
+export function addPromptToActivity(activity, line) {
+    const session = activity.sessions[line.sessionId];
+    if (session) {
+        if (line.timestamp < session.startedAt)
+            session.startedAt = line.timestamp;
+        if (line.timestamp > session.lastActiveAt) {
+            session.lastActiveAt = line.timestamp;
+        }
+        session.promptCount += 1;
+    }
+    else {
+        activity.sessions[line.sessionId] = {
+            startedAt: line.timestamp,
+            lastActiveAt: line.timestamp,
+            promptCount: 1,
+        };
+    }
+    const date = toDateStr(line.timestamp);
+    const day = activity.daily[date];
+    if (day) {
+        day.prompts += 1;
+        day.words += line.words;
+    }
+    else {
+        activity.daily[date] = { prompts: 1, words: line.words };
+    }
+    return { sessionId: line.sessionId, date };
+}
+/**
+ * Where the histogram's axis ends for this user's own distribution: their p90
+ * prompt length rounded up to a multiple of 10, clamped to [10, 100]. Anything
+ * longer is reported by `buildTail` instead.
  *
  * Per-user rather than fixed because prompt length varies enormously between
  * people — a fixed axis would either crush a terse user's histogram into the
@@ -83,23 +255,72 @@ export function bucketMaxFor(wordCounts) {
     if (wordCounts.length === 0)
         return PROMPT_LENGTH_BUCKET_MIN;
     const sorted = [...wordCounts].sort((a, b) => a - b);
-    const index = Math.min(sorted.length - 1, Math.floor(sorted.length * PROMPT_LENGTH_OVERFLOW_PERCENTILE));
+    const index = Math.min(sorted.length - 1, Math.floor(sorted.length * PROMPT_LENGTH_AXIS_PERCENTILE));
     const p90 = sorted[index] ?? PROMPT_LENGTH_BUCKET_MIN;
     const rounded = Math.ceil(p90 / 10) * 10;
     return Math.min(PROMPT_LENGTH_BUCKET_MAX, Math.max(PROMPT_LENGTH_BUCKET_MIN, rounded));
 }
 /**
- * Bucket the word counts. Buckets `1..bucketMax-1` are exact word counts; the
- * bucket at `bucketMax` is the overflow, holding every prompt that long or
- * longer. Empty buckets are omitted — the chart fills the gaps.
+ * Bucket the word counts. Every bucket `1..bucketMax` is an exact word count —
+ * there is no overflow bar. Empty buckets are omitted; the chart fills the gaps.
+ *
+ * Prompts longer than `bucketMax` are not in here at all: they are reported by
+ * `buildTail`, and only there. So the histogram and the tail partition the
+ * scan — sum(histogram counts) + sum(tail counts) === totalPrompts, always.
  */
 export function buildHistogram(wordCounts, bucketMax) {
     const counts = new Map();
     for (const words of wordCounts) {
         if (words <= 0)
             continue;
-        const bucket = words >= bucketMax ? bucketMax : words;
-        counts.set(bucket, (counts.get(bucket) ?? 0) + 1);
+        if (words > bucketMax)
+            continue;
+        counts.set(words, (counts.get(words) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([length, count]) => ({ length, count }))
+        .sort((a, b) => a.length - b.length);
+}
+/**
+ * The exact distribution of everything *longer* than `bucketMax`, which the
+ * histogram does not cover at all. One entry per distinct word count,
+ * ascending; empty (never absent) when nothing exceeds `bucketMax` — the
+ * field's presence on the wire is the marker that the histogram's bars are
+ * exact.
+ *
+ * Lengths only — no prompt text is involved here, or anywhere near it.
+ *
+ * A machine with a long history can have thousands of distinct long lengths,
+ * far past what the server accepts, so an over-cap tail is coarsened: lengths
+ * are rounded to multiples of 2, then 4, 8, … until at most
+ * `PROMPT_TAIL_MAX_ENTRIES` entries remain, summing the counts that collapse
+ * together. Rounding is *up* so that a coarsened entry still sits above
+ * `bucketMax` — rounding down could claim a length inside the histogram's own
+ * exact range for a prompt the histogram never counted.
+ *
+ * Deterministic: the result depends only on the multiset of word counts.
+ */
+export function buildTail(wordCounts, bucketMax) {
+    const exact = new Map();
+    for (const words of wordCounts) {
+        if (words <= bucketMax)
+            continue;
+        exact.set(words, (exact.get(words) ?? 0) + 1);
+    }
+    if (exact.size === 0)
+        return [];
+    let counts = exact;
+    let step = 1;
+    while (counts.size > PROMPT_TAIL_MAX_ENTRIES) {
+        step *= 2;
+        const coarser = new Map();
+        // Always coarsen from the exact counts, so the rounding is one clean
+        // division rather than a rounding of a rounding.
+        for (const [length, count] of exact) {
+            const rounded = Math.ceil(length / step) * step;
+            coarser.set(rounded, (coarser.get(rounded) ?? 0) + count);
+        }
+        counts = coarser;
     }
     return [...counts.entries()]
         .map(([length, count]) => ({ length, count }))
@@ -121,6 +342,22 @@ export async function gitOriginUrl(cwd) {
         return null;
     }
 }
+/**
+ * Newest transcript first. The sample is meant to be the user's *recent*
+ * prompting, so the walk order has to be time order — the directory walk's own
+ * order is alphabetical and would hand the scorer whatever happens to sort
+ * first, which for a long-lived machine is usually a project abandoned years
+ * ago. A file we can't stat sorts last rather than dropping out.
+ */
+async function byMtimeDesc(paths) {
+    const stamped = await Promise.all(paths.map(async (path) => ({
+        path,
+        mtimeMs: await stat(path)
+            .then((s) => s.mtimeMs)
+            .catch(() => 0),
+    })));
+    return stamped.sort((a, b) => b.mtimeMs - a.mtimeMs).map((f) => f.path);
+}
 /**
  * Scan the local Claude Code transcripts.
  *
@@ -130,10 +367,11 @@ export async function gitOriginUrl(cwd) {
  */
 export async function scanPromptStats(options = {}) {
     const root = join(homedir(), '.claude', 'projects');
-    const files = await findFiles(root, '.jsonl');
+    const files = await byMtimeDesc(await findFiles(root, '.jsonl'));
     if (files.length === 0)
         return null;
     const wordCounts = [];
+    const activity = emptyPromptActivity();
     const sampleParts = [];
     let sampleChars = 0;
     // Keyed by the transcript's project directory, which is Claude Code's own
@@ -154,6 +392,12 @@ export async function scanPromptStats(options = {}) {
         catch {
             continue;
         }
+        // Within a file the newest prompts are last, so the sample is drained in
+        // reverse after the file is read. Only collected while the budget is still
+        // open, so a full sample doesn't hold a whole history in memory.
+        const collectSample = options.includeSample === true &&
+            sampleChars < CONVERSATION_SAMPLE_MAX_CHARS;
+        const fileSample = [];
         for (const line of content.split('\n')) {
             if (!line.trim())
                 continue;
@@ -176,17 +420,22 @@ export async function scanPromptStats(options = {}) {
                 continue;
             wordCounts.push(words);
             project.promptCount += 1;
-            if (typeof entry.timestamp === 'string') {
-                const at = Date.parse(entry.timestamp);
-                if (Number.isFinite(at) && at > project.lastActiveAt) {
-                    project.lastActiveAt = at;
-                }
-            }
-            if (options.includeSample &&
-                sampleChars < CONVERSATION_SAMPLE_MAX_CHARS) {
-                sampleParts.push(text);
-                sampleChars += text.length + 2;
+            const at = Date.parse(String(entry.timestamp));
+            if (Number.isFinite(at) && at > project.lastActiveAt) {
+                project.lastActiveAt = at;
             }
+            const promptLine = parsePromptLine(line);
+            if (promptLine)
+                addPromptToActivity(activity, promptLine);
+            if (collectSample)
+                fileSample.push(text);
+        }
+        for (let i = fileSample.length - 1; i >= 0; i--) {
+            if (sampleChars >= CONVERSATION_SAMPLE_MAX_CHARS)
+                break;
+            const text = fileSample[i];
+            sampleParts.push(text);
+            sampleChars += text.length + 2;
         }
     }
     if (wordCounts.length === 0)
@@ -196,7 +445,9 @@ export async function scanPromptStats(options = {}) {
         totalPrompts: wordCounts.length,
         bucketMax,
         histogram: buildHistogram(wordCounts, bucketMax),
+        tail: buildTail(wordCounts, bucketMax),
         projects: await resolveProjects(byProjectDir),
+        activity,
     };
     if (options.includeSample && sampleParts.length > 0) {
         stats.conversationSample = sampleParts
@@ -205,6 +456,15 @@ export async function scanPromptStats(options = {}) {
     }
     return stats;
 }
+/**
+ * The `promptStats` block as the server takes it. `activity` is deliberately
+ * dropped: it is local bookkeeping for the tick's incremental state, and it
+ * travels under its own top-level `promptActivity` field instead.
+ */
+export function promptStatsPayload(stats) {
+    const { activity: _activity, ...wire } = stats;
+    return wire;
+}
 /**
  * Turn the per-directory tallies into repo-keyed entries. Directories with no
  * prompts, no recorded `cwd`, or no git origin drop out — the backend can only