@usagefleet/cli 1.2.151 → 1.2.153

package/README.md

@@ -97,7 +97,8 @@ directory, git branch. Prompts, responses and file contents are never read.
 
 The first time a window crosses a threshold (default `80` and `95`) you get a
 desktop notification — once per threshold per window, re-armed when the window
-resets. macOS uses `osascript`, Linux `notify-send` (falling back to
+resets. macOS shows it from a small bundled UsageFleet app (allow it once when
+macOS asks; a click opens the dashboard), Linux uses `notify-send` (falling back to
 `kdialog --passivepopup`; install `libnotify-bin` if neither exists), Windows a
 WinRT toast via `powershell.exe`.
 

package/dist/UsageFleet.app/Contents/Info.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleIdentifier</key>
+	<string>dev.usagefleet.notifier</string>
+	<key>CFBundleName</key>
+	<string>UsageFleet</string>
+	<key>CFBundleDisplayName</key>
+	<string>UsageFleet</string>
+	<key>CFBundleExecutable</key>
+	<string>usagefleet-notifier</string>
+	<key>CFBundleIconFile</key>
+	<string>AppIcon</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>11.0</string>
+	<key>LSUIElement</key>
+	<true/>
+</dict>
+</plist>

package/dist/UsageFleet.app/Contents/_CodeSignature/CodeResources

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>files</key>
+	<dict>
+		<key>Resources/AppIcon.icns</key>
+		<data>
+		Qsu2PdOnquUAUG4LLkSUe3XpdqA=
+		</data>
+	</dict>
+	<key>files2</key>
+	<dict>
+		<key>Resources/AppIcon.icns</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			yxmneUbIT7WvXoxaR+DXAKCF/pbzjexThOZ9bg8UK3E=
+			</data>
+		</dict>
+	</dict>
+	<key>rules</key>
+	<dict>
+		<key>^Resources/</key>
+		<true/>
+		<key>^Resources/.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^Resources/.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Resources/Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^version.plist$</key>
+		<true/>
+	</dict>
+	<key>rules2</key>
+	<dict>
+		<key>.*\.dSYM($|/)</key>
+		<dict>
+			<key>weight</key>
+			<real>11</real>
+		</dict>
+		<key>^(.*/)?\.DS_Store$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>2000</real>
+		</dict>
+		<key>^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/</key>
+		<dict>
+			<key>nested</key>
+			<true/>
+			<key>weight</key>
+			<real>10</real>
+		</dict>
+		<key>^.*</key>
+		<true/>
+		<key>^Info\.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^PkgInfo$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^Resources/</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^Resources/.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^Resources/.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Resources/Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^[^/]+$</key>
+		<dict>
+			<key>nested</key>
+			<true/>
+			<key>weight</key>
+			<real>10</real>
+		</dict>
+		<key>^embedded\.provisionprofile$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^version\.plist$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+	</dict>
+</dict>
+</plist>

package/dist/collector.js

@@ -18,6 +18,8 @@ import { fetchGroupLimits, postLimits, uploadBatch } from './uploader.js';
  *  uuids) and other JSONL — restricting to this subtree mirrors Claude Code and
  *  avoids re-uploading every desktop record twice. */
 const PROJECTS_SUBPATH = `${sep}.claude${sep}projects${sep}`;
+/** `status` shows the cached reading's age, so it stays within this of the last check. */
+const LIMITS_CACHE_REFRESH_MS = 10 * 60_000;
 /**
  * One full scan: tail every JSONL file from its stored offset, upload new usage
  * records (chunked to batchSize), and commit each file's offset only after all
@@ -25,7 +27,7 @@ const PROJECTS_SUBPATH = `${sep}.claude${sep}projects${sep}`;
  */
 export async function runOnce(cfg, log = () => {
     /* empty */
-}) {
+}, dirCache = new Map()) {
     const { state } = readStore(cfg.storePath);
     // Each scan root is tagged with the app that owns it. Claude Code's projects
     // dir is scanned whole; the Claude Desktop sessions root is filtered to its
@@ -41,7 +43,7 @@ export async function runOnce(cfg, log = () => {
     }
     const files = [];
     for (const root of roots) {
-        for (const fp of listJsonlFiles(root.dir)) {
+        for (const fp of listJsonlFiles(root.dir, dirCache)) {
             if (root.onlyProjects && !fp.includes(PROJECTS_SUBPATH)) {
                 continue;
             }
@@ -75,7 +77,7 @@ export async function runOnce(cfg, log = () => {
         if (!tail || tail.consumedBytes === 0) {
             continue;
         }
-        if (tail.records.length === 0) {
+        if (tail.segments.length === 0) {
             // Consumed only non-usage lines — safe to advance immediately.
             state.files[fp] = tail.nextState;
             advanced = true;
@@ -83,8 +85,8 @@ export async function runOnce(cfg, log = () => {
         }
         // sendChunk absorbs "invalid" by bisecting, so only auth/plan/transient escape.
         let outcome = 'ok';
-        for (let i = 0; i < tail.records.length; i += step) {
-            outcome = await sendChunk(tail.records.slice(i, i + step), cfg, result, log);
+        for (const chunk of chunks(tail.segments, step)) {
+            outcome = await sendChunk(chunk.records, chunk.accountExtId, cfg, result, log);
             if (outcome !== 'ok') {
                 break;
             }
@@ -151,9 +153,9 @@ export async function runOnce(cfg, log = () => {
  * anything that survives that many splits is not record-shaped.
  */
 const MAX_DROPPED_PER_CHUNK = 2;
-async function sendChunk(records, cfg, result, log, dropCeiling = result.dropped + MAX_DROPPED_PER_CHUNK) {
+async function sendChunk(records, accountExtId, cfg, result, log, dropCeiling = result.dropped + MAX_DROPPED_PER_CHUNK) {
     const res = await uploadBatch({
-        accountExtId: detectClaudeAccount()?.extId,
+        accountExtId: accountExtId ?? detectClaudeAccount()?.extId,
         collectorVersion: RELEASE_VERSION,
         hostname: hostname(),
         os: detectOs(),
@@ -185,21 +187,34 @@ async function sendChunk(records, cfg, result, log, dropCeiling = result.dropped
         return 'ok';
     }
     const mid = Math.ceil(records.length / 2);
-    const head = await sendChunk(records.slice(0, mid), cfg, result, log, dropCeiling);
-    return head === 'ok' ? sendChunk(records.slice(mid), cfg, result, log, dropCeiling) : head;
+    const head = await sendChunk(records.slice(0, mid), accountExtId, cfg, result, log, dropCeiling);
+    return head === 'ok' ? sendChunk(records.slice(mid), accountExtId, cfg, result, log, dropCeiling) : head;
+}
+/** Upload-sized slices of each segment; a chunk never spans two accounts. */
+function chunks(segments, step) {
+    const out = [];
+    for (const { accountExtId, records } of segments) {
+        for (let i = 0; i < records.length; i += step) {
+            out.push({ accountExtId, records: records.slice(i, i + step) });
+        }
+    }
+    return out;
 }
 /**
  * Drop offsets for logs that no longer exist on disk, so a long-lived install
  * does not grow its state file by one entry per Claude session forever. Only
  * paths absent from this cycle's scan are stat'd, and only a real ENOENT prunes
- * — a root that is merely unconfigured right now keeps its offsets.
+ * — a root that is merely unconfigured right now keeps its offsets. A path that
+ * still exists goes too when its inode is one this scan reached under another
+ * path: a root now read through a symlink (~/.pi -> .dotfiles/.pi).
  * Returns whether anything was removed.
  */
 function pruneMissingFiles(state, scanned) {
     const seen = new Set(scanned.map(f => f.fp));
+    const seenInodes = new Set(scanned.map(f => state.files[f.fp]?.inode));
     let removed = false;
-    for (const fp of Object.keys(state.files)) {
-        if (seen.has(fp) || existsSync(fp)) {
+    for (const [fp, file] of Object.entries(state.files)) {
+        if (seen.has(fp) || (existsSync(fp) && !seenInodes.has(file.inode))) {
             continue;
         }
         // oxlint-disable-next-line typescript/no-dynamic-delete -- state.files is a JSON blob keyed by path
@@ -272,8 +287,16 @@ export async function reportLimitsOnce(cfg, log = () => {
         log('warn', 'limits upload failed · retrying next cycle');
     }
     // Cache the reading so `status` can show current usage without spending
-    // another billable API call.
+    // another billable API call. An unchanged reading refreshes its timestamp only
+    // every LIMITS_CACHE_REFRESH_MS: each save rewrites the whole store.
     updateStore(cfg.storePath, store => {
+        const cached = store.limits;
+        const unchanged = cached?.fiveHourPct === report.fiveHourPct &&
+            cached.sevenDayPct === report.sevenDayPct &&
+            cached.source === report.source;
+        if (unchanged && Date.now() - Date.parse(cached.at) < LIMITS_CACHE_REFRESH_MS) {
+            return;
+        }
         store.limits = {
             at: new Date().toISOString(),
             fiveHourPct: report.fiveHourPct,

package/dist/index.js

@@ -96,13 +96,14 @@ async function cmdWatch() {
     let stopping = false;
     let timer = null;
     let running = false;
+    const dirCache = new Map();
     const tick = async () => {
         if (stopping) {
             return;
         }
         running = true;
         try {
-            const r = await runOnce(cfg, stream);
+            const r = await runOnce(cfg, stream, dirCache);
             // Dropped records are real data loss, so they must show up even in a
             // cycle that uploaded nothing.
             if (r.sent > 0 || r.dropped > 0) {

package/dist/notifier.js

@@ -18,17 +18,19 @@ export function loadNotifyConfig(env = process.env, file = readStore()) {
  * Decide whether a window crosses a not-yet-notified threshold. Pure — no IO.
  * Returns the threshold to fire (or null) and the next persisted state.
  *
- * A window rollover (resetsAt change) resets the high-water mark first, so the
+ * A window rollover (resetsAt moves) resets the high-water mark first, so the
  * first crossing in a new window always re-notifies. If utilization later drops
  * below the mark within the SAME window (e.g. a server correction), the mark is
  * lowered so a subsequent re-cross notifies again.
  */
 export function evaluateWindow(prev, pct, resetsAt, thresholds) {
-    const rolledOver = !prev || prev.resetsAt !== resetsAt;
+    const rolledOver = !prev || !sameWindow(prev.resetsAt, resetsAt);
     const lastBucket = rolledOver ? 0 : prev.lastBucket;
+    // Within a window the first resetsAt stays, so the jitter alone never rewrites the store.
+    const windowResetsAt = rolledOver ? resetsAt : prev.resetsAt;
     if (pct == null) {
         // No reading this cycle — keep the mark, just track the (possibly new) window.
-        return { fire: null, next: { lastBucket, resetsAt } };
+        return { fire: null, next: { lastBucket, resetsAt: windowResetsAt } };
     }
     // Highest threshold the current pct has reached (thresholds are ascending).
     let top = 0;
@@ -38,10 +40,17 @@ export function evaluateWindow(prev, pct, resetsAt, thresholds) {
         }
     }
     if (top > lastBucket) {
-        return { fire: top, next: { lastBucket: top, resetsAt } };
+        return { fire: top, next: { lastBucket: top, resetsAt: windowResetsAt } };
     }
     // top <= lastBucket: the mark follows pct down (or holds); nothing fires.
-    return { fire: null, next: { lastBucket: top, resetsAt } };
+    return { fire: null, next: { lastBucket: top, resetsAt: windowResetsAt } };
+}
+// oauth/usage jitters resets_at by milliseconds per request; a real rollover moves it by hours.
+function sameWindow(a, b) {
+    if (a === null || b === null) {
+        return a === b;
+    }
+    return Math.abs(Date.parse(a) - Date.parse(b)) < 60_000;
 }
 /** Relative "resets in 12m" / "resets in 2h" suffix, or "" if unknown/past. */
 function resetSuffix(resetsAt) {

package/dist/notify.js

@@ -1,4 +1,10 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
+import { cpSync, existsSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ENDPOINT } from './config.js';
+import { notifierAppPath } from './service.js';
+const NOTIFIER_EXE = join('Contents', 'MacOS', 'usagefleet-notifier');
 /** Collapse every whitespace run (including the raw newlines AppleScript string
  *  literals forbid) to a single space, leaving hyphens and other punctuation
  *  intact. */
@@ -26,6 +32,36 @@ function spawnQuiet(cmd, args, onError) {
     }
 }
 function notifyMac(title, message) {
+    // macos/build.sh puts the app next to this file in the npm release; dev runs have none.
+    const bundled = fileURLToPath(new URL('UsageFleet.app', import.meta.url));
+    if (!existsSync(bundled)) {
+        notifyOsascript(title, message);
+        return;
+    }
+    const app = notifierAppPath();
+    installNotifierApp(bundled, app);
+    const child = spawn(join(app, NOTIFIER_EXE), [oneLine(title), oneLine(message), `${ENDPOINT}/dashboard`], {
+        // Own process group: launchd kills the collector's group when it restarts, and the
+        // first-run permission prompt keeps the app alive until the user answers it.
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.on('error', () => notifyOsascript(title, message));
+    child.unref();
+}
+/** Copies the app to one fixed path, so macOS sees a single UsageFleet app whatever
+ *  Node install runs the CLI. Replaces it only when the build changed. */
+export function installNotifierApp(from, to) {
+    const exe = join(to, NOTIFIER_EXE);
+    if (existsSync(exe) && readFileSync(exe).equals(readFileSync(join(from, NOTIFIER_EXE)))) {
+        return;
+    }
+    const tmp = `${to}.${process.pid}.tmp`;
+    cpSync(from, tmp, { recursive: true });
+    rmSync(to, { recursive: true, force: true });
+    renameSync(tmp, to);
+}
+function notifyOsascript(title, message) {
     // execFile (no shell) — the only interpolation surface is the AppleScript
     // string, which osaEscape neutralizes.
     const script = `display notification "${osaEscape(message)}" with title "${osaEscape(title)}"`;
@@ -64,7 +100,7 @@ function notifyWindows(title, message) {
 /**
  * Show a desktop notification. Best-effort and non-blocking: it never throws and
  * never blocks the caller. Supported platforms:
- *   - macOS: `osascript` -> Notification Center.
+ *   - macOS: the bundled UsageFleet.app, or `osascript` when it is missing.
  *   - Linux: `notify-send` (KDE Plasma + other freedesktop daemons), falling
  *     back to `kdialog --passivepopup` on KDE.
  *   - Windows: WinRT toast via `powershell.exe` -> Action Center.

package/dist/paths.js

@@ -1,3 +1,4 @@
+import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 // USAGEFLEET_PROJECTS is resolved in config.ts's precedence chain, not here —
@@ -42,7 +43,25 @@ export function defaultPiSessionsDirs() {
     if (agent) {
         dirs.push(join(agent, 'sessions'));
     }
-    return [...new Set(dirs)];
+    // pi exports its dir resolved (~/.pi -> .dotfiles/.pi gives the .dotfiles path), so one
+    // root can arrive twice. The first path wins: it is the one the service, without pi's env, scans.
+    const unique = new Map();
+    for (const dir of dirs) {
+        const real = realDir(dir);
+        if (!unique.has(real)) {
+            unique.set(real, dir);
+        }
+    }
+    return [...unique.values()];
+}
+function realDir(dir) {
+    try {
+        return realpathSync(dir);
+    }
+    catch {
+        // Missing roots are normal (pi never ran here) and scan to nothing.
+        return dir;
+    }
 }
 /** pi's agent dir, the root for its sessions and extensions.
  *  PI_CODING_AGENT_DIR is pi's own relocation knob; unlike the service-side

package/dist/release.js

@@ -1,2 +1,2 @@
 // Generated by .github/workflows/release.yml.
-export const RELEASE_VERSION = "1.2.151";
+export const RELEASE_VERSION = "1.2.153";

package/dist/scanner.js

@@ -1,24 +1,58 @@
-import { readdirSync } from 'node:fs';
+import { readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+// Linux stamps mtimes with a jiffy-coarse clock, HFS+ by the second, FAT by two: a change
+// right after a read can carry the listing's mtime. Only a folder quiet this long is trusted.
+const QUIET_MS = 10_000;
 /** Recursively list all *.jsonl files under a directory. Returns [] if the
- *  directory is missing. */
-export function listJsonlFiles(dir) {
-    const out = [];
+ *  directory is missing. A folder whose mtime has not moved reuses its listing
+ *  from `cache`: adding or removing an entry moves it, appending to a log does not. */
+export function listJsonlFiles(dir, cache = new Map()) {
+    const listing = listDir(dir, cache);
+    const out = [...listing.files];
+    for (const sub of listing.dirs) {
+        out.push(...listJsonlFiles(sub, cache));
+    }
+    return out;
+}
+function listDir(dir, cache) {
+    const cached = cache.get(dir);
+    const readAt = Date.now();
+    let mtimeMs;
     let entries;
     try {
+        mtimeMs = statSync(dir).mtimeMs;
+        if (cached?.mtimeMs === mtimeMs) {
+            return cached;
+        }
         entries = readdirSync(dir, { withFileTypes: true });
     }
     catch {
-        return out;
+        forget(cache, dir);
+        return { dirs: [], files: [], mtimeMs: null };
     }
+    const listing = { dirs: [], files: [], mtimeMs: readAt - mtimeMs > QUIET_MS ? mtimeMs : null };
     for (const e of entries) {
         const full = join(dir, e.name);
         if (e.isDirectory()) {
-            out.push(...listJsonlFiles(full));
+            listing.dirs.push(full);
         }
         else if (e.isFile() && e.name.endsWith('.jsonl')) {
-            out.push(full);
+            listing.files.push(full);
         }
     }
-    return out;
+    const kept = new Set(listing.dirs);
+    for (const sub of cached?.dirs ?? []) {
+        if (!kept.has(sub)) {
+            forget(cache, sub);
+        }
+    }
+    cache.set(dir, listing);
+    return listing;
+}
+function forget(cache, dir) {
+    const listing = cache.get(dir);
+    cache.delete(dir);
+    for (const sub of listing?.dirs ?? []) {
+        forget(cache, sub);
+    }
 }

package/dist/service.js

@@ -15,7 +15,7 @@ const TASK = 'usagefleet';
  *  service that lost it would silently report the default account instead. */
 const EXTRA_PASSTHROUGH_ENV = new Set(['ANTHROPIC_API_KEY', 'CLAUDE_CONFIG_DIR']);
 /** Per-user dir for the collector's own runtime files: the Windows launcher and
- *  its log, plus the binary copy that pre-npm releases left there. */
+ *  its log, the macOS notifier app, plus the binary copy that pre-npm releases left there. */
 function stableBinDir() {
     if (process.platform === 'darwin') {
         return join(homedir(), 'Library', 'Application Support', 'usagefleet');
@@ -39,6 +39,10 @@ function macLogDir() {
 function windowsVbsPath() {
     return join(stableBinDir(), 'usagefleet-watch.vbs');
 }
+/** One fixed path for the macOS notifier, whatever Node install runs the CLI. */
+export function notifierAppPath() {
+    return join(stableBinDir(), 'UsageFleet.app');
+}
 /** Where releases before the npm switch parked their copy of the binary. Only
  *  cleanup touches it now. */
 function stableBinPath() {
@@ -553,7 +557,8 @@ export function uninstall() {
             }
         }
         removeStableBin();
-        console.log(step('removed', 'launchd agent'));
+        rmSync(notifierAppPath(), { force: true, recursive: true });
+        console.log(step('removed', 'launchd agent · notification app'));
         console.log(row('leftover', `${tilde(path)} · delete to fully clean up`));
         return;
     }

package/dist/store.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { writeFileAtomic } from './atomic-write.js';
@@ -108,7 +108,13 @@ export function readStore(path = storePath()) {
  */
 export function updateStore(path, mutate) {
     const store = readStore(path);
+    const before = JSON.stringify(store);
     mutate(store);
+    // The offsets make the store ~0.5 MB, so an unchanged one is not rewritten. A missing
+    // file always is: it pins the deviceId normalize() just generated and folds the legacy files.
+    if (existsSync(path) && JSON.stringify(store) === before) {
+        return;
+    }
     mkdirSync(dirname(path), { recursive: true });
     // 0600: the file holds the device token.
     writeFileAtomic(path, `${JSON.stringify(store, null, 2)}\n`, 0o600);

package/dist/tailer.js

@@ -5,6 +5,8 @@ import { dim, line, tilde, yellow } from './ui.js';
 const MAX_READ = 16 * 1024 * 1024;
 // Both parsers need a `usage` object, and about 3/4 of log bytes are lines without one.
 const USAGE_KEY = Buffer.from('"usage"');
+// Unescaped quotes: the same text quoted inside a message is `\"customType\"` and never matches.
+const ACCOUNT_KEY = Buffer.from('"customType":"claude-account"');
 /**
  * The working directory of a pi session, read from the file's first line
  * (`{"type":"session",…,"cwd":"/path"}`). pi's message lines carry no cwd, and
@@ -26,6 +28,18 @@ function piSessionCwd(fd) {
         return null;
     }
 }
+/** The account a pi session pinned itself to, from the dotfiles claude-accounts extension's
+ *  `{"type":"custom","customType":"claude-account","data":{"email","uuid"}}` line. Every
+ *  later line in the file ran on it, until the next such line. */
+function piSessionAccount(line) {
+    try {
+        const uuid = JSON.parse(line)?.data?.uuid;
+        return typeof uuid === 'string' && uuid !== '' ? uuid.slice(0, 100) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Read new, newline-terminated lines from `filePath` starting at the previously
  * stored offset. Handles rotation/truncation (inode change or size < offset →
@@ -41,9 +55,10 @@ export function tailFile(filePath, prev, source = 'cli') {
     }
     const rotated = prev !== undefined && (st.ino !== prev.inode || st.size < prev.offset);
     const start = rotated || prev === undefined ? 0 : prev.offset;
-    const base = { inode: Number(st.ino), offset: start };
+    const startAccount = rotated ? undefined : prev?.accountExtId;
+    const base = { accountExtId: startAccount, inode: Number(st.ino), offset: start };
     if (st.size <= start) {
-        return { consumedBytes: 0, nextState: base, records: [] };
+        return { consumedBytes: 0, nextState: base, segments: [] };
     }
     // Cap the per-cycle read so a huge backlog can't OOM; the next cycle resumes
     // from the committed offset.
@@ -70,29 +85,53 @@ export function tailFile(filePath, prev, source = 'cli') {
             return {
                 consumedBytes: length,
                 nextState: { ...base, offset: start + length },
-                records: [],
+                segments: [],
             };
         }
-        return { consumedBytes: 0, nextState: base, records: [] };
+        return { consumedBytes: 0, nextState: base, segments: [] };
     }
     const consumed = buf.subarray(0, lastNl + 1);
-    // Decode only the lines that can hold usage: decoding and splitting the whole
-    // 16 MB read peaked a first-run backlog at ~490 MB RSS.
-    const records = [];
-    let at = consumed.indexOf(USAGE_KEY);
-    while (at !== -1) {
+    // Decode only the lines that can hold usage or a pi account switch: decoding and
+    // splitting the whole 16 MB read peaked a first-run backlog at ~490 MB RSS.
+    const segments = [];
+    let account = startAccount;
+    let usageAt = consumed.indexOf(USAGE_KEY);
+    let accountAt = source === 'pi' ? consumed.indexOf(ACCOUNT_KEY) : -1;
+    while (usageAt !== -1 || accountAt !== -1) {
+        const isAccountLine = accountAt !== -1 && (usageAt === -1 || accountAt < usageAt);
+        const at = isAccountLine ? accountAt : usageAt;
         const lineStart = consumed.lastIndexOf(0x0a, at) + 1;
         const lineEnd = consumed.indexOf(0x0a, at);
-        const rec = parseLine(consumed.toString('utf-8', lineStart, lineEnd), source, sessionCwd);
-        if (rec) {
-            records.push(rec);
+        const text = consumed.toString('utf-8', lineStart, lineEnd);
+        if (isAccountLine) {
+            account = piSessionAccount(text);
+        }
+        else {
+            const rec = parseLine(text, source, sessionCwd);
+            if (rec) {
+                addRecord(segments, account, rec);
+            }
+        }
+        if (usageAt !== -1 && usageAt < lineEnd) {
+            usageAt = consumed.indexOf(USAGE_KEY, lineEnd);
+        }
+        if (accountAt !== -1 && accountAt < lineEnd) {
+            accountAt = consumed.indexOf(ACCOUNT_KEY, lineEnd);
         }
-        at = consumed.indexOf(USAGE_KEY, lineEnd);
     }
     const consumedBytes = consumed.length;
     return {
         consumedBytes,
-        nextState: { ...base, offset: start + consumedBytes },
-        records,
+        nextState: { accountExtId: account, inode: base.inode, offset: start + consumedBytes },
+        segments,
     };
 }
+function addRecord(segments, accountExtId, record) {
+    const last = segments.at(-1);
+    if (last && last.accountExtId === accountExtId) {
+        last.records.push(record);
+    }
+    else {
+        segments.push({ accountExtId, records: [record] });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@usagefleet/cli",
-	"version": "1.2.151",
+	"version": "1.2.153",
 	"description": "Tails Claude Code, Claude Desktop, and pi agent JSONL logs and reports token usage to a UsageFleet server.",
 	"keywords": [
 		"claude",