worktrust 0.6.7 → 0.6.10

package/README.md

@@ -35,9 +35,38 @@ curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
 4. **Earlier work only if you say yes.** It counts the Claude Code and Codex sessions already on
    this computer and asks `Send these as history? [y/N]`. Enter sends nothing. What goes is hours
    and tokens per day, never text, and WorkTrust shows it as earlier work, never as verified hours.
+   Nothing from before the coupling is ever sent without that yes: the session hook starts at the
+   moment of coupling.
+5. **Codex only if you say yes.** With Codex on this computer it asks `Let Codex wake the session
+   hook? [y/N]` and, on a yes, sets the one `notify` line in `~/.codex/config.toml` (the file is
+   kept as `config.toml.worktrust-backup` first). Another program's `notify` is never replaced.
+6. **Antigravity only if you say yes.** With Google Antigravity on this computer it asks `Let
+   Antigravity wake the session hook? [y/N]` and, on a yes, adds one hook named `worktrust` with a
+   single `Stop` command to `~/.gemini/config/hooks.json` (kept as `hooks.json.worktrust-backup`
+   first). Other hooks in that file stay as they are. Antigravity records no token counts, so its
+   sessions arrive with durations and turn counts only.
+7. **Hermes Agent with the other apps.** With Hermes on this computer (`~/.hermes`, and every profile
+   under `~/.hermes/profiles`) its `config.yaml` gets the WorkTrust entry under `mcp_servers` and one
+   `on_session_end` hook that wakes the session hook; Hermes itself asks once before it runs a new
+   hook. A file that writes those sections inline is left as it is. The session hook reads Hermes's
+   own `state.db`: clocks, roles, the model and the session's token totals, never a message. A chat
+   app (Telegram, WhatsApp, Slack …) is sent as work steered from elsewhere; a subagent's, a
+   scheduled job's or a board task's session is not counted. Needs Node 22.5 or newer.
+8. **Goose, OpenCode and OpenClaw the same way.** Goose gets the entry under `extensions` in
+   `~/.config/goose/config.yaml` and one plugin folder, `~/.agents/plugins/worktrust`, whose
+   SessionEnd hook wakes the session hook. OpenCode gets it under `mcp` in
+   `~/.config/opencode/opencode.json` (a file with comments is left as it is) and one plugin file,
+   `plugin/worktrust.js`, that wakes the session hook when a session goes idle. OpenClaw is coupled
+   through its own `openclaw mcp set` (and `openclaw mcp unset` on disconnect); without that command
+   on this computer it is printed for you to run. Each is read from its own session database, the
+   same way as Hermes: clocks, roles, models and token counts, never a message. OpenClaw's Talk
+   sessions are sent as voice, its chat-app sessions as remote; subagents and scheduled runs are
+   not counted.
 
 ```
 npx worktrust history       send this computer's earlier sessions later (asks first)
+npx worktrust codex         let Codex wake the session hook (asks first)
+npx worktrust antigravity   let Antigravity wake the session hook (asks first)
 npx worktrust status        what is coupled here
 npx worktrust disconnect    take it out again (shows the plan, asks first)
 ```
@@ -65,9 +94,9 @@ which would delete every password on the computer, and many people rightly keep
 
 | | |
 |---|---|
-| **Reads** | Which AI apps are installed (the settings folders of Claude Code, Codex, Cursor, Gemini CLI, VS Code, Windsurf). Afterwards, the session hook reads Claude Code's and Codex's own session files on this computer to measure durations and token counts. |
-| **Writes** | The key file (above). In each AI app's MCP settings (`~/.claude.json` through `claude mcp`, `~/.cursor/mcp.json`, `~/.codex/config.toml`, `~/.gemini/settings.json`, VS Code's `mcp.json`, Windsurf's `mcp_config.json`) a WorkTrust entry that runs the local bridge, with no key in it; three hooks in `~/.claude/settings.json`; the bridge, the hook and the counter in `~/.worktrust/`. |
-| **Sends, to pair** | This computer's system (macOS, Windows, Linux) and host name. Not its network address. |
+| **Reads** | Which AI apps are installed (the settings folders of Claude Code, Codex, Cursor, Gemini CLI, Antigravity, VS Code, Windsurf, Hermes Agent, Goose, OpenCode, OpenClaw). Afterwards, the session hook reads Claude Code's, Codex's and Antigravity's session files and the session databases of Hermes, Goose, OpenCode and OpenClaw on this computer to measure durations and token counts. |
+| **Writes** | The key file (above). In each AI app's MCP settings (`~/.claude.json` through `claude mcp`, `~/.cursor/mcp.json`, `~/.codex/config.toml`, `~/.gemini/settings.json`, `~/.gemini/config/mcp_config.json` (Antigravity), VS Code's `mcp.json`, Windsurf's `mcp_config.json`, Hermes's and Goose's `config.yaml`, OpenCode's `opencode.json`, OpenClaw through `openclaw mcp set`) a WorkTrust entry that runs the local bridge, with no key in it; three hooks in `~/.claude/settings.json`; the bridge, the hook and the counter in `~/.worktrust/`. |
+| **Sends, to pair** | This computer's system (macOS, Windows, Linux) and host name. WorkTrust also records the network address the request arrives from, as a security record kept 90 days and seen only by WorkTrust staff (to answer a theft or fraud report). |
 | **Sends, afterwards** | Durations, token counts, model names, one layer keyword (frontend, backend …), counts of how you work. |
 | **Never sends** | Prompts, answers, code, file names or paths, commit messages, branch or project names. The door has no field for them and refuses a submission that carries them. |
 
@@ -86,10 +115,27 @@ which would delete every password on the computer, and many people rightly keep
 - **The key** never appears on a command line a process list could show: it is written to its file
   and reaches the bridge and the hook only in their environment.
 
+## A computer that is already coupled, or shared
+
+- `npx worktrust connect` on a computer that is already coupled says to which account (masked) and
+  asks `Couple it again? [y/N]`. Enter and `--yes` mean No; `--replace` says yes in advance.
+- The browser page that approves it shows, large, which WorkTrust account is signed in, with
+  **Use another account**: the computer goes to whoever approves it there.
+- Once the new key is in place, the old key is ended at WorkTrust (the request is signed by this
+  computer's own device key). An AI app still open on the old key is refused and moves to the new one.
+- When the new account is a different one, the old account sees a notice that its computer moved,
+  with the computer's name and the moment, never the other account; no earlier work on this
+  computer is offered to the new account, only work from the moment of coupling.
+- `npx worktrust status` shows the account this computer sends to.
+- Different people on one computer with their own OS user each couple their own: everything lives
+  in that user's home folder, and the accounts never meet.
+
 ## Undo
 
-`npx worktrust disconnect` removes the WorkTrust entries, the hook and the key file, and empties
-`~/.worktrust`.
+`npx worktrust disconnect` removes the WorkTrust entries (Hermes's hook with them), the hook (and Codex's `notify` line and
+Antigravity's `worktrust` hook when WorkTrust set them) and the key file, and empties
+`~/.worktrust` but for one small note of which account it fed (masked), so that a later coupling by
+another account offers none of this computer's earlier work.
 Then revoke the key in WorkTrust: Sources → Devices → this computer → Revoke.
 
 ## Requirements

package/config-edits.mjs

@@ -0,0 +1,69 @@
+/**
+ * CONFIG EDITS — a YAML file edited line by line, never re-serialised (2026-10-05).
+ *
+ * Hermes Agent and Goose keep their settings in YAML, written by people, with comments and their own indentation.
+ * setup-mcp.mjs puts WorkTrust's entry into them and takes it out again with these: a section is found by its key at
+ * a known indent, an entry is added at the indent its siblings use, and a removal leaves every other byte as it was.
+ * Only block style is handled; a section written inline (`key: { … }`) makes placeUnder return false, and the caller
+ * leaves the file alone. No dependency: it ships beside setup-mcp.mjs.
+ */
+const indentOf = (line) => line.length - line.trimStart().length;
+const meaningful = (line) => line.trim() !== "" && !line.trimStart().startsWith("#");
+/** `key:` at `indent` between start and stop: its line and the end of its block, or the inline value it carries. */
+function section(lines, start, stop, indent, key) {
+  for (let i = start; i < stop; i += 1) {
+    if (!meaningful(lines[i]) || indentOf(lines[i]) !== indent) continue;
+    const match = new RegExp(`^\\s*${key}:(?:\\s+(.*?))?\\s*$`).exec(lines[i]);
+    if (!match) continue;
+    const inline = match[1] && !match[1].startsWith("#") ? match[1] : null;
+    let end = i + 1;
+    while (end < stop && (!meaningful(lines[end]) || indentOf(lines[end]) > indent || (indentOf(lines[end]) === indent && lines[end].trimStart().startsWith("-")))) end += 1;
+    while (end > i + 1 && !meaningful(lines[end - 1])) end -= 1;
+    return { at: i, end, inline };
+  }
+  return null;
+}
+/** The entries of a block (a mapping's keys or a list's items), each [from, to). */
+function entries(lines, at, end) {
+  const starts = [];
+  const first = lines.slice(at + 1, end).find(meaningful);
+  const child = first === undefined ? null : indentOf(first);
+  for (let i = at + 1; i < end; i += 1) if (meaningful(lines[i]) && indentOf(lines[i]) === child) starts.push(i);
+  return { child, ranges: starts.map((from, n) => [from, starts[n + 1] ?? end]) };
+}
+const EMPTY_INLINE = new Set(["{}", "[]", "null", "~"]);
+/** Puts `unit` under the path, making each section that is missing; false when one is written inline. */
+export function placeUnder(lines, path, unit) {
+  let start = 0, stop = lines.length, indent = 0;
+  for (const [n, key] of path.entries()) {
+    let found = section(lines, start, stop, indent, key);
+    if (found?.inline && !EMPTY_INLINE.has(found.inline)) return false;
+    if (found?.inline) lines[found.at] = `${" ".repeat(indent)}${key}:`;
+    if (!found) { lines.splice(stop, 0, `${" ".repeat(indent)}${key}:`); found = { at: stop, end: stop + 1 }; }
+    const child = entries(lines, found.at, found.end).child ?? indent + 2;
+    if (n === path.length - 1) { lines.splice(found.end, 0, ...unit.map((line) => " ".repeat(child) + line)); return true; }
+    start = found.at + 1; stop = found.end; indent = child;
+  }
+  return true;
+}
+/** The section at the end of a path, in block style; null when absent or inline. */
+function find(lines, path) {
+  let start = 0, stop = lines.length, indent = 0, found = null;
+  for (const key of path) {
+    found = section(lines, start, stop, indent, key);
+    if (!found || found.inline) return null;
+    start = found.at + 1; stop = found.end; indent = entries(lines, found.at, found.end).child ?? indent + 2;
+  }
+  return found;
+}
+/** Takes out every entry under the path that is ours, and a section that leaves empty. */
+export function takeOut(lines, path, mine) {
+  const found = find(lines, path);
+  if (!found) return;
+  let removed = 0;
+  for (const [from, to] of entries(lines, found.at, found.end).ranges.reverse()) if (mine(lines.slice(from, to).join("\n"))) { lines.splice(from, to - from); removed += 1; }
+  if (removed > 0) for (let depth = path.length; depth > 0; depth -= 1) {
+    const left = find(lines, path.slice(0, depth));
+    if (left && !lines.slice(left.at + 1, left.end).some(meaningful)) lines.splice(left.at, left.end - left.at);
+  }
+}

package/count-behaviour.mjs

@@ -1,7 +1,7 @@
 /**
  * THE LOCAL COUNTER — rubric v0.1 (`counter@0.1.0`).
  *
- * Reads this machine's own Claude Code transcripts, its Codex rollouts (2026-09-27), its VS Code
+ * Reads this machine's own Claude Code transcripts, its Codex rollouts (2026-09-27), its Antigravity conversations (2026-10-04), its VS Code
  * Copilot chat sessions (2026-09-08) and, when given, a claude.ai export (~/.claude/projects/**​/*.jsonl — transcripts
  * ONLY, never project files), classifies each of the person's OWN messages with the
  * deterministic rules below, and reports COUNTS per month through the WorkTrust MCP door's
@@ -625,101 +625,12 @@ function* claudeExportSessions() {
     }
   }
 }
-// ── codex rollout reader (the same text in count-behaviour.mjs and log-session.mjs; test-codex-rollout holds them equal) ──
 /**
- * A CODEX ROLLOUT, READ AS A TRANSCRIPT (2026-09-27). Codex keeps one JSONL per thread under
- * ~/.codex/sessions/YYYY/MM/DD/rollout-<stamp>-<uuid>.jsonl: a session_meta line, then per turn a
- * turn_context (model, effort, cwd), response_items (messages, tool calls, their outputs) and a
- * token_usage_record per model response. On the machine this was built on five of them held 679
- * million tokens that nothing read. This turns the records into the lines Claude Code writes, so
- * ONE rubric and ONE clock read both:
- *   · a user or assistant message → a user or assistant line with a text part; the developer line
- *     and the harness's own user-role messages (<environment_context>, <recommended_plugins> and
- *     the like: a tag opening the text) are the harness, not the person, and are dropped;
- *   · a tool call → an assistant line with a tool_use part: `exec` becomes Bash with the command
- *     as input, `apply_patch` an Edit with the first path it names, `spawn_agent` an Agent; its
- *     output → a user line with a tool_result, is_error read from Codex's own "exit code N";
- *   · a token_usage_record → an assistant line carrying the usage in Claude's keys, ONCE per
- *     response_id (Codex writes a response more than once): input minus cached is new input,
- *     cached is a cache read, cache_write a cache write, output already holds the reasoning tokens.
- * The running total in event_msg/token_count is never read: it is a counter, not a record.
- * Text is read here for the rubric and the layer and travels nowhere, as with every transcript.
+ * THE READERS FOR CODEX AND ANTIGRAVITY live in transcript-readers.mjs beside this file (2026-10-04;
+ * the session hook imports the same file). Run alone, without it, the counter reads Claude Code,
+ * Copilot and an export, and says that Codex and Antigravity were not read.
  */
-const CODEX_ROLLOUT = /(^|\/)rollout-\d{4}-\d{2}-\d{2}T[\d-]+-[0-9a-f-]{36}\.jsonl$/;
-const CODEX_HARNESS_TURN = /^\s*<[a-z][a-z_]*[\s>]/i;
-const codexToolName = (name) => (name === "exec" || name === "shell" || name === "container.exec" || name === "local_shell" ? "Bash" : name === "apply_patch" ? "Edit" : name === "spawn_agent" ? "Agent" : String(name ?? "tool"));
-const codexToolInput = (name, raw) => {
-  const mapped = codexToolName(name);
-  if (mapped === "Bash") {
-    if (typeof raw === "string") { try { const parsed = JSON.parse(raw); if (parsed && typeof parsed === "object") return { command: Array.isArray(parsed.command) ? parsed.command.join(" ") : String(parsed.command ?? parsed.cmd ?? raw) }; } catch { /* the string is the command */ } return { command: raw }; }
-    return { command: Array.isArray(raw?.command) ? raw.command.join(" ") : String(raw?.command ?? raw?.cmd ?? "") };
-  }
-  if (mapped === "Edit") { const path = /\*\*\* (?:Update|Add|Delete) File: ([^\n]+)/.exec(typeof raw === "string" ? raw : JSON.stringify(raw ?? "")); return { file_path: path ? path[1].trim() : "" }; }
-  return {};
-};
-const codexOutputText = (output) => (typeof output === "string" ? output : Array.isArray(output) ? output.map((part) => (typeof part === "string" ? part : part?.text ?? "")).join("\n") : "");
-/** The rollout's raw JSON lines → transcript-shaped line objects, in file order. */
-function* codexLines(records) {
-  let cwd = null, model = null;
-  const seenResponses = new Set();
-  for (const raw of records) {
-    if (!raw || !String(raw).trim()) continue;
-    let record; try { record = JSON.parse(raw); } catch { continue; }
-    const timestamp = typeof record?.timestamp === "string" ? record.timestamp : null;
-    const payload = record?.payload && typeof record.payload === "object" ? record.payload : {};
-    if (record.type === "session_meta") { if (typeof payload.cwd === "string") cwd = payload.cwd; continue; }
-    if (record.type === "turn_context") { if (typeof payload.cwd === "string") cwd = payload.cwd; if (typeof payload.model === "string") model = payload.model; continue; }
-    if (record.type === "token_usage_record") {
-      const id = String(payload.response_id ?? "");
-      const usage = payload.usage;
-      if (!usage || typeof usage !== "object" || (id && seenResponses.has(id))) continue;
-      if (id) seenResponses.add(id);
-      const n = (key) => (typeof usage[key] === "number" && Number.isFinite(usage[key]) ? usage[key] : 0);
-      yield { type: "assistant", timestamp, cwd, uuid: id ? `codex-usage-${id}` : undefined, message: { ...(model ? { model } : {}), content: [], usage: { input_tokens: Math.max(0, n("input_tokens") - n("cached_input_tokens")), output_tokens: n("output_tokens"), cache_read_input_tokens: n("cached_input_tokens"), cache_creation_input_tokens: n("cache_write_input_tokens") } } };
-      continue;
-    }
-    if (record.type !== "response_item") continue;
-    const kind = payload.type;
-    if (kind === "message") {
-      if (payload.role !== "user" && payload.role !== "assistant") continue;
-      const text = Array.isArray(payload.content) ? payload.content.filter((part) => typeof part?.text === "string").map((part) => part.text).join("\n") : typeof payload.content === "string" ? payload.content : "";
-      if (payload.role === "user" && CODEX_HARNESS_TURN.test(text)) continue;
-      yield { type: payload.role, timestamp, cwd, uuid: payload.id ? `codex-${payload.id}` : undefined, message: { ...(payload.role === "assistant" && model ? { model } : {}), content: [{ type: "text", text }] } };
-      continue;
-    }
-    if (kind === "custom_tool_call" || kind === "function_call") {
-      const input = kind === "function_call" ? (() => { try { return JSON.parse(payload.arguments ?? "{}"); } catch { return {}; } })() : payload.input;
-      yield { type: "assistant", timestamp, cwd, uuid: payload.id ? `codex-${payload.id}` : undefined, message: { ...(model ? { model } : {}), content: [{ type: "tool_use", ...(payload.call_id ? { id: String(payload.call_id) } : {}), name: codexToolName(payload.name), input: codexToolInput(payload.name, input) }] } };
-      continue;
-    }
-    if (kind === "custom_tool_call_output" || kind === "function_call_output") {
-      const text = codexOutputText(payload.output);
-      const exit = /(?:failed with|exited with|exit code)[:\s]+(-?\d+)/i.exec(text.slice(-400));
-      yield { type: "user", timestamp, cwd, uuid: payload.id ? `codex-${payload.id}` : undefined, message: { content: [{ type: "tool_result", ...(payload.call_id ? { tool_use_id: String(payload.call_id) } : {}), content: text, is_error: exit ? exit[1] !== "0" : false }] } };
-    }
-  }
-}
-/** Every rollout under a Codex sessions root, in a stable order. */
-function* codexRolloutFiles(root) {
-  let entries = []; try { entries = readdirSync(root, { withFileTypes: true }); } catch { return; }
-  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    const full = join(root, entry.name);
-    if (entry.isDirectory()) yield* codexRolloutFiles(full);
-    else if (CODEX_ROLLOUT.test(entry.name)) yield full;
-  }
-}
-/** The rollout's working directory, from its first line alone: the file is not read for it. */
-function codexCwd(file) {
-  let fd; try { fd = openSync(file, "r"); } catch { return null; }
-  try {
-    const buffer = Buffer.allocUnsafe(64 * 1024);
-    const read = readSync(fd, buffer, 0, buffer.length, 0);
-    const first = buffer.toString("utf8", 0, read).split("\n")[0] ?? "";
-    const meta = JSON.parse(first);
-    return meta?.type === "session_meta" && typeof meta.payload?.cwd === "string" ? meta.payload.cwd : null;
-  } catch { return null; } finally { closeSync(fd); }
-}
-// ── end codex rollout reader ──
+const { codexLines, codexRolloutFiles, codexCwd, antigravityLines, antigravityRoots, antigravityTranscripts, antigravityContext } = (await import("./transcript-readers.mjs").catch(() => null)) ?? {};
 
 /**
  * Codex rollouts, as sessions. The real ~/.codex/sessions is read when nothing was overridden;
@@ -730,7 +641,7 @@ function codexCwd(file) {
  */
 let codexRolloutCount = 0;
 function* codexSessions() {
-  if (flag("no-codex")) return;
+  if (flag("no-codex") || !codexRolloutFiles) return;
   const given = value("codex-root");
   if (!given && value("transcript-root")) return;
   const root = (given ?? join(homedir(), ".codex", "sessions")).replace(/^~(?=\/|$)/, homedir());
@@ -744,6 +655,21 @@ function* codexSessions() {
     yield { key: file, projectDir, basename, path: file, codex: true };
   }
 }
+/** Antigravity conversations (2026-10-04), the same way: --antigravity-root for a test, --no-antigravity to leave them out; the folder the Stop hook named decides --exclude. */
+let antigravityCount = 0;
+function* antigravitySessions() {
+  const given = value("antigravity-root");
+  if (flag("no-antigravity") || !antigravityTranscripts || (!given && value("transcript-root"))) return;
+  for (const { conversationId, file } of antigravityTranscripts(antigravityRoots(given))) {
+    const context = antigravityContext(conversationId);
+    const basename = context.cwd ? String(context.cwd).split("/").filter(Boolean).at(-1) ?? null : null;
+    if (basename && excluded(basename)) { skippedDirs.push(`antigravity:${basename}`); continue; }
+    const projectDir = basename ? `antigravity-${basename}` : "antigravity";
+    if (!countedDirs.includes(projectDir)) countedDirs.push(projectDir);
+    antigravityCount += 1;
+    yield { key: file, projectDir, basename, path: file, antigravity: { id: conversationId, ...context } };
+  }
+}
 /** Every session the rubric reads: a transcript file, or one conversation from a claude.ai export. */
 /**
  * v0.10: a transcript is READ AS A STREAM of lines. Reading a whole file into one string failed
@@ -782,6 +708,7 @@ function* sessions() {
   }
   // A rollout is a transcript on this machine, so --only-transcripts keeps it.
   yield* codexSessions();
+  yield* antigravitySessions();
   if (!flag("only-transcripts")) { yield* claudeExportSessions(); yield* copilotSessions(); }
 }
 
@@ -899,7 +826,7 @@ const seenLines = new Set(); // v0.10: line identities already counted (a uuid o
 // scan; complete session boundaries preserve signals that depend on earlier turns.
 const manifest = [];
 for(const session of sessions())manifest.push(sessionDigest(session));
-exportConversations = 0; copilotSessionCount = 0; codexRolloutCount = 0; skippedDirs.length = 0; countedDirs.length = 0; skippedConversations.length = 0;
+exportConversations = 0; copilotSessionCount = 0; codexRolloutCount = 0; antigravityCount = 0; skippedDirs.length = 0; countedDirs.length = 0; skippedConversations.length = 0;
 const checkpoint = flag("no-checkpoint") || LABEL_OUT ? null : checkpointStore(
   value("checkpoint") ?? join(homedir(), ".worktrust", "counter-checkpoint.json"),
   fingerprint({code:readFileSync(new URL(import.meta.url)),version:ANALYZER_VERSION,months:MONTHS_BACK,thisMonth,exclude:EXCLUDE,leaveOut:LEAVE_OUT,exports:EXPORTS}),manifest);
@@ -959,7 +886,7 @@ for (const session of sessions()) {
   let lineNo = 0;
   // Streamed either way; a Codex rollout's stream is shaped into transcript lines as it passes.
   const rawLines = session.path ? fileLines(session.path, streamHash) : session.lines;
-  for (const entry of session.codex ? codexLines(rawLines) : rawLines) {
+  for (const entry of session.codex ? codexLines(rawLines) : session.antigravity ? antigravityLines(rawLines, session.antigravity) : rawLines) {
     lineNo += 1;
     if (!entry) continue;
     currentUnit = unitOf(file, lineNo);
@@ -1269,6 +1196,8 @@ console.log(` projects counted: ${countedDirs.length}${countedDirs.length ? ` ($
 console.log(` git side: ${gitSideCommits} own commit(s) read for test-first order and decision records (paths stay here)`);
 console.log(` lines read once: ${duplicateLines} line(s) already counted from another transcript file were skipped${unreadableLines ? ` · ${unreadableLines} line(s) too long to read` : ""}`);
 if (copilotSessionCount > 0) console.log(` copilot chat sessions read: ${copilotSessionCount} (VS Code workspaceStorage, this machine)`);
+if (!codexLines) console.log(" codex and antigravity: not read (transcript-readers.mjs is not beside this file)");
+if (antigravityCount > 0) console.log(` antigravity conversations read: ${antigravityCount} (~/.gemini/antigravity*, this machine; clocks and the person's turns, no tokens recorded)`);
 if (codexRolloutCount > 0) console.log(` codex rollouts read: ${codexRolloutCount} (~/.codex/sessions, this machine; tokens once per response, the person's turns only)`);
 if (EXPORTS.length > 0) console.log(` claude.ai export: ${exportConversations} conversation(s) counted${skippedConversations.length ? ` · excluded, never read: ${skippedConversations.length}` : ""}`);
 if (skippedDirs.length > 0) console.log(` excluded, never read: ${skippedDirs.join(", ")}`);