worktrust 0.6.14 → 0.6.16

package/README.md

@@ -38,7 +38,7 @@ yourself run a command that sends. See [Keep your history](#keep-your-history).
 3. **The terminal finishes by itself.** It keeps the key in its private file and gives every
    AI app here the WorkTrust door, then installs the session hook. Quit your AI apps and open them
    again.
-4. **Earlier work only if you say yes.** It counts the Claude Code and Codex sessions already on
+4. **Earlier work only if you say yes.** It counts your AI apps' 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
@@ -202,11 +202,11 @@ 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, Antigravity, VS Code, Windsurf, Hermes Agent, Goose, OpenCode, OpenClaw), and the chats Cursor and Copilot keep (clocks, models and token counts only). 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. |
+| **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), and the chats Cursor and Copilot keep (clocks, models and token counts only). Afterwards, the session hook reads Claude Code's, Codex's and Antigravity's session files, the session databases of Hermes, Goose, OpenCode and OpenClaw, and the chats Cursor and Copilot keep, 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. |
+| **Sends, afterwards** | Per measured stretch of work, and nothing else: its durations (`seconds`, `duration_basis`, `model_seconds`, `tool_seconds`, `human_seconds`, `idle_seconds`), token counts (`tokens_in`, `tokens_out`, `tokens_cache_read`, `tokens_cache_write`, `token_basis`), the model's name (`model`), the kind of work and one layer keyword such as frontend or backend (`title`, `kind`, `layer`, `layers`), counts of how you work (`exchanges`, `turn_basis`, `agent_runs`, `agent_seconds`, `agent_peak`), when it ended (`at`), a hash of the session and the day (`stretch_ref`), `steered_from` when it ran over SSH, and, so the work can be matched to GitHub, the repository as its remote's owner/name (`repo`) and the hashes of the commits made in the stretch (`commits`, never their messages). |
+| **Never sends** | Prompts, answers, code, file names or paths, commit messages, branch names, or the name of your local folder (a repository is named only as its remote's owner/name, above). The door has no field for them and refuses a submission that carries them. |
 
 ## Why you can check it
 

package/config-edits.mjs

@@ -67,3 +67,18 @@ export function takeOut(lines, path, mine) {
     if (left && !lines.slice(left.at + 1, left.end).some(meaningful)) lines.splice(left.at, left.end - left.at);
   }
 }
+
+/**
+ * ONLY THE HOUSE'S OWN DOOR (0.6.16, audit L5; the same rule as log-session.mjs and count-behaviour.mjs): an MCP address is
+ * WorkTrust's when its path is /api/mcp and its host is worktrust.io or a subdomain over https, the host WORKTRUST_MCP_URL
+ * names, or this computer. `/api/mcp` alone is every hosted MCP server's conventional path, so another product's entry is
+ * never adopted as the coupling, and never taken out with it.
+ */
+export const isWorkTrustDoor = (url) => {
+  try {
+    const parsed = new URL(String(url));
+    if (!/\/api\/mcp\/?$/.test(parsed.pathname)) return false;
+    const own = process.env.WORKTRUST_MCP_URL ? new URL(process.env.WORKTRUST_MCP_URL).host : null;
+    return parsed.protocol === "https:" && (parsed.hostname === "worktrust.io" || parsed.hostname.endsWith(".worktrust.io")) || (own !== null && parsed.host === own) || parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+  } catch { return false; }
+};

package/log-session.mjs

@@ -38,8 +38,8 @@
  * `worktrust.mjs hook --antigravity-stop`. The readers live in transcript-readers.mjs beside this file.
  *
  * WHAT CANNOT LEAVE. The payload is built from a fixed allowlist of keys, all of them numbers,
- * dates or vocabulary from the door's own enums. No prompt, no answer, no file path, no commit
- * message, no branch, no project name. File paths ARE read locally to decide one layer keyword,
+ * dates or vocabulary from the door's own enums, and the repository as owner/name and commit hashes. No prompt, no
+ * answer, no file path, no commit message, no branch, no folder name. File paths ARE read locally to decide one layer keyword,
  * the way the connector reads them to decide an activity class, and only the keyword travels.
  *
  * WHAT IS MEASURED, AND WHAT IS THEREFORE NOT SENT. A stretch's seconds are the sum of the gaps
@@ -209,9 +209,10 @@ const excluded = (path) => excludes.some((text) => text && path.includes(text));
  * reader), the database clients in session-databases.mjs. The install copies both into ~/.worktrust with this hook.
  * Without them this hook still reads Claude Code; the never-matching patterns keep every other client out.
  */
-const { CODEX_ROLLOUT = /(?!)/, codexLines, codexRolloutFiles = function* () {}, codexCwd = () => null, ANTIGRAVITY_TRANSCRIPT = /(?!)/, antigravityLines, antigravityRoots = () => [], antigravityTranscripts = function* () {}, antigravityContext = () => ({}), rememberAntigravity = () => null } = (await import("./transcript-readers.mjs").catch(() => null)) ?? {};
+const { CODEX_ROLLOUT = /(?!)/, codexIdOf = (file) => String(file).split(/[\\/]/).at(-1).replace(/\.jsonl$/, ""), antigravityIdOf = (file) => String(file).split(/[\\/]/).at(-4), codexLines, codexRolloutFiles = function* () {}, codexCwd = () => null, ANTIGRAVITY_TRANSCRIPT = /(?!)/, antigravityLines, antigravityRoots = () => [], antigravityTranscripts = function* () {}, antigravityContext = () => ({}), rememberAntigravity = () => null } = (await import("./transcript-readers.mjs").catch(() => null)) ?? {};
 const { DATABASE_SESSION = /(?!)/, databaseLines = () => null, databaseSessions = function* () {} } = (await import("./session-databases.mjs").catch(() => null)) ?? {};
 const DATABASE_CLIENTS = ["hermes", "goose", "opencode", "openclaw", "cursor", "copilot"]; // the registry's keys, the name each line carries
+const LIVE_SOURCE = new RegExp(`^(codex|antigravity|${DATABASE_CLIENTS.join("|")}):`); // a sweep entry's id → the client it names (every database client, 0.6.16)
 const READER_FILES = ["transcript-readers.mjs", "session-databases.mjs"];
 /** The readers go where the hook and the counter run: copied from beside this file, else (or for a newer counter) from the deployment. */
 async function installReaders(origin, fromNetwork = false) {
@@ -236,7 +237,7 @@ function* codexRollouts() {
   for (const file of root ? codexRolloutFiles(root) : []) {
     const cwd = codexCwd(file);
     if (cwd && excluded(cwd)) continue;
-    yield { id: `codex:${file.split("/").at(-1).replace(/\.jsonl$/, "")}`, file };
+    yield { id: `codex:${codexIdOf(file)}`, file };
   }
   yield* antigravityConversations();
   yield* databaseConversations();
@@ -261,7 +262,7 @@ const parsedLines = (file) => {
   if (DATABASE_SESSION.test(file)) return databaseLines(file);
   let lines; try { lines = readFileSync(file, "utf8").split("\n"); } catch { return null; }
   if (CODEX_ROLLOUT.test(file)) return [...codexLines(lines)];
-  if (ANTIGRAVITY_TRANSCRIPT.test(file)) { const id = file.split("/").at(-4); return [...antigravityLines(lines, { id, ...antigravityContext(id) })]; }
+  if (ANTIGRAVITY_TRANSCRIPT.test(file)) { const id = antigravityIdOf(file); return [...antigravityLines(lines, { id, ...antigravityContext(id) })]; }
   const out = [];
   for (const raw of lines) { if (!raw.trim()) continue; try { out.push(JSON.parse(raw)); } catch { /* a torn line */ } }
   return out;
@@ -365,7 +366,7 @@ const messageOf = (line, at) => {
     toolUse: line.type === "assistant" && blocks.some((block) => block && block.type === "tool_use"),
     // A tool that waits for the PERSON (a question, a plan to approve): the gap to its result is the person's, not the tool's. The name is read, never the input.
     waitsForPerson: line.type === "assistant" && blocks.some((block) => block && block.type === "tool_use" && WAITS_FOR_PERSON.has(String(block.name))),
-    agentic: line.agentic === true,
+    agentic: line.agentic === true, cumulative: line.cumulative === true, // the session's running totals (Hermes, Goose without a ledger)
   };
 };
 
@@ -463,7 +464,7 @@ function measure(cwd, messages) {
   }
   const model = [...models.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
   const tokens = tokensOf(messages);
-  return { cwd, seconds: measured, layers: measured !== null ? timeLayers(messages) : null, ...tokens, exchanges, model, from: messages[0].at, to: messages[messages.length - 1].at };
+  return { cwd, seconds: measured, layers: measured !== null ? timeLayers(messages) : null, ...tokens, cumulative: messages.some((message) => message.cumulative), exchanges, model, from: messages[0].at, to: messages[messages.length - 1].at };
 }
 
 /**
@@ -523,10 +524,15 @@ function tokensOf(messages) {
   if (!shapeKnown) return { tokensIn: 0, tokensOut: 0, cacheRead: 0, cacheWrite: 0, shapeKnown: false };
   return { tokensIn, tokensOut, cacheRead, cacheWrite, shapeKnown: counted > 0 };
 }
-
-// WHICH STRETCH, HOW STEERED (0.6.10): a hash of the session id (the file name) and the day, the same on any computer, so a
-// restored backup is never counted twice; `remote` only when the session runs over SSH, otherwise nothing is said.
-const stretchRef = (file, day) => createHash("sha256").update(`worktrust-stretch|${String(file).split(/[\\/]/).pop().replace(/\.jsonl?$/, "")}|${day}`).digest("base64url");
+// A SESSION'S TOTALS ARE SENT ONCE (0.6.16, audit H2). Hermes, and Goose without its ledger, keep tokens per SESSION on its last answer, so a resumed
+// session sent its whole total again. Such a stretch sends what the total grew by since the one reported (kept beside the watermark), never a negative.
+const TOTALS = ["tokensIn", "tokensOut", "cacheRead", "cacheWrite"];
+const grownBy = (stretch, reported) => { if (!stretch.cumulative || !stretch.shapeKnown) return reported; const total = Object.fromEntries(TOTALS.map((key) => [key, Math.max(stretch[key], reported?.[key] ?? 0)]));
+  for (const key of TOTALS) stretch[key] = Math.max(0, stretch[key] - (reported?.[key] ?? 0)); return total; }; // the total to keep; a fresh session sends its total, as before
+
+// WHICH STRETCH, HOW STEERED (0.6.10): a hash of the session id (the file name; Antigravity's, always transcript.jsonl, its conversation's folder) and the day,
+// the same on any computer, so a restored backup is never counted twice; `remote` only when the session runs over SSH, otherwise nothing is said.
+const stretchRef = (file, day) => createHash("sha256").update(`worktrust-stretch|${ANTIGRAVITY_TRANSCRIPT.test(file) ? antigravityIdOf(file) : String(file).split(/[\\/]/).pop().replace(/\.jsonl?$/, "")}|${day}`).digest("base64url");
 const STEERED_HERE = process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY ? "remote" : null;
 
 /** The one payload shape this script can build. Every key is a number, a date or an enum value. */
@@ -668,7 +674,8 @@ function historyEntries(floor = null, all = false) {
       entries.push(entry);
     }
   }
-  return entries.sort((a, b) => a.at.localeCompare(b.at));
+  const seen = new Set(); // ONE SESSION FILE IN TWO PROJECT FOLDERS (a copied folder) IS ONE STRETCH (0.6.16, audit M6), as live and preserve count it
+  return entries.filter((entry) => !seen.has(entry.stretch_ref) && seen.add(entry.stretch_ref)).sort((a, b) => a.at.localeCompare(b.at));
 }
 
 /** Every transcript this machine holds, excluded projects skipped before a file is opened. */
@@ -901,51 +908,44 @@ if (floorOf(state, "__from") === null) {
   if (!DRY) writeState(state);
 }
 const floor = floorOf(state, "__from");
-let sent = 0;
-let filed = 0;
-/** Measured days the live door will no longer take. They are not dropped; they are filed. */
-const late = [];
+let sent = 0, filed = 0;
+const late = []; // measured days the live door will no longer take: they are not dropped, they are filed
+const heldBack = new Map(); // per transcript with a late day: its state before that day, put back unless history took every late day
 for (const entry of work) {
   const mark = state[entry.id]?.through ? Date.parse(state[entry.id].through) : null;
   // Never before the coupling (THE FLOORS): a transcript with no watermark starts at `__from`, not at its first line.
   const since = mark !== null && floor !== null ? Math.max(mark, floor) : mark ?? floor;
-  // Nothing has been written since we last read this one — no need to open it at all. This is what
-  // keeps a sweep over every transcript on the machine to one `stat` each.
+  // Nothing written since we last read this one: it is not opened. This keeps a sweep over every transcript to one `stat` each.
   if (since !== null && entry.writtenAt && entry.writtenAt <= since) continue;
   const stretches = stretchesOf(entry.file, since);
   // THE WATERMARK ADVANCES OVER WHAT WAS ACCEPTED, AND STOPS AT THE FIRST REFUSAL. A door that is
   // down must never cost the person a day, so the loop breaks rather than skipping ahead.
-  let through = null;
+  let through = null, before, reported = state[entry.id]?.reported;
   for (const stretch of stretches) {
     // The day still being worked in is not finished. A fortnight-long session therefore reports
     // every day but today, on whichever run comes first — it no longer waits for its own end.
     if (Date.now() - stretch.to < IDLE_BEFORE_SWEEP) break;
+    const total = grownBy(stretch, reported);
     const payload = payloadFor(stretch);
-    const source = /^(codex|antigravity|hermes|goose|opencode|openclaw):/.exec(String(entry.id))?.[1];
+    const source = LIVE_SOURCE.exec(String(entry.id))?.[1];
     if (source) entrySource.set(payload, source);
-    if (DRY) { console.log(JSON.stringify({ ...payload, client: source ?? "claude", route: Date.now() - stretch.to > WINDOW_HOURS * 3600_000 ? "history" : "log_work" }, null, 1)); through = stretch.to; continue; }
-    // MEASURED TIME IS NEVER DROPPED. The live door takes work as it happens and refuses anything
-    // older than two days — which is right, and used to mean a machine that was closed for a
-    // fortnight lost the fortnight. The same measured numbers go through the history door instead:
-    // recorded, marked as history, standing as history stands. Late is not the same as untrue.
-    if (Date.now() - stretch.to > WINDOW_HOURS * 3600_000) { late.push(payload); through = stretch.to; continue; }
-    try {
-      await send(doorFor(entry), payload);
-      through = stretch.to;
-      sent += 1;
-    } catch (error) {
+    if (DRY) { console.log(JSON.stringify({ ...payload, client: source ?? "claude", route: Date.now() - stretch.to > WINDOW_HOURS * 3600_000 ? "history" : "log_work" }, null, 1)); through = stretch.to; reported = total; continue; }
+    // MEASURED TIME IS NEVER DROPPED. The live door refuses anything older than two days, which is right, and used to mean a machine closed
+    // for a fortnight lost the fortnight. The same numbers go through the history door instead, standing as history stands. Late is not untrue.
+    if (Date.now() - stretch.to > WINDOW_HOURS * 3600_000) { before ??= { mark: through === null ? state[entry.id] : { ...state[entry.id], through: new Date(through).toISOString() } }; late.push(payload); through = stretch.to; reported = total; continue; }
+    try { await send(doorFor(entry), payload); through = stretch.to; reported = total; sent += 1; } catch (error) {
       if (process.env.WORKTRUST_HOOK_DEBUG) console.error(`worktrust: ${error.message}`);
       break;
     }
   }
-  if (through !== null) state[entry.id] = { through: new Date(through).toISOString() };
+  if (before && !heldBack.has(entry.id)) heldBack.set(entry.id, before.mark);
+  if (through !== null) state[entry.id] = { through: new Date(through).toISOString(), ...(reported ? { reported } : {}) };
 }
-// The history door, in one batch per two hundred, exactly as `--history` sends them. A resend
-// FILLS a line that was missing something rather than adding a twin, so a repeated run is safe.
+// The history door, in batches of two hundred as `--history` sends them. A resend FILLS a line that was missing something, never a twin.
 if (!DRY && late.length > 0) {
-  try { filed = await sendHistory(door, late); } catch (error) {
-    if (process.env.WORKTRUST_HOOK_DEBUG) console.error(`worktrust: ${error.message}`);
-  }
+  try { filed = await sendHistory(door, late); } catch (error) { if (process.env.WORKTRUST_HOOK_DEBUG) console.error(`worktrust: ${error.message}`); }
+  // A LATE DAY THE HISTORY DOOR REFUSED IS NOT PASSED: its transcript's mark goes back to before it, so the next run sends it again.
+  if (filed < late.length) for (const [id, mark] of heldBack) { if (mark) state[id] = mark; else delete state[id]; }
 }
 if (!DRY && (sent > 0 || filed > 0)) writeState(state);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "description": "Couple this computer to WorkTrust: approve a code in your browser, and every AI app here reports what you built. Metadata only, no dependencies.",
   "type": "module",
   "bin": {

package/preserve-summary.mjs

@@ -1,8 +1,8 @@
 /**
  * --summary: what a person or a team reads from the archive, counted locally after the chain checks out. Per month the
  * hours, the tokens per model and the share of input served from the cache (where the tokens go, and so where they
- * can be saved); and the PARALLEL WORK: per project and day the sessions' summed time against the wall-clock time they
- * covered together, and the most open at once. A stretch without a project or a measured token stays out of that
+ * can be saved); and the PARALLEL WORK: per project and day the sessions' open spans added up against the wall-clock
+ * time they covered together (spans on both sides, so the sum is never below the clock), and the most open at once. A stretch without a project or a measured token stays out of that
  * figure; nothing is estimated.
  *
  * Pure: the archive's verified lines in, the lines to print out. No file, no clock, no network.
@@ -31,7 +31,7 @@ export function summaryLines(lines) {
       const edges = spans.flatMap(([from, to]) => [[from, 1], [to, -1]]).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
       let open = 0, top = 0, covered = 0, since = 0;
       for (const [at, step] of edges) { if (open > 0) covered += at - since; open += step; since = at; top = Math.max(top, open); }
-      if (top > 1) { parallelDays += 1; peak = Math.max(peak, top); summed += spans.reduce((sum, span) => sum + span[2], 0); wall += covered / 1000; }
+      if (top > 1) { parallelDays += 1; peak = Math.max(peak, top); summed += spans.reduce((sum, [from, to]) => sum + (to - from), 0) / 1000; wall += covered / 1000; }
     }
     if (parallelDays > 0) out.push(`    parallel sessions in one project on ${parallelDays} day${parallelDays === 1 ? "" : "s"}: up to ${peak} at once, ${hours(summed)} h of session time in ${hours(wall)} h of wall-clock time`);
   }

package/preserve.mjs

@@ -274,12 +274,12 @@ function archive(dir) {
   // A WHOLE ANSWER OR NOTHING: the hook ends with its own count; one line missing or cut is a read to refuse, never part of an archive.
   const rows = hook.stdout.split("\n").filter(Boolean), end = (() => { try { return JSON.parse(rows.at(-1) ?? "").archive_end; } catch { return undefined; } })();
   if (!Number.isInteger(end) || end !== rows.length - 1) { say(`  The session hook's answer came back incomplete (${rows.length - 1} of ${end ?? "an unknown number of"} lines), so nothing was added. Run it again.`); process.exit(1); }
-  const known = new Set(existing.lines.map((line) => line.stretch_ref)), fresh = [];
+  const known = new Set(existing.lines.map((line) => line.stretch_ref)), fresh = [], measured = new Set();
   let waiting = 0;
   for (const text of rows.slice(0, -1)) {
     let entry; try { entry = JSON.parse(text); } catch { continue; }
     const line = archiveLine(entry);
-    if (!line || known.has(line.stretch_ref)) continue;
+    if (line && line.day < today()) measured.add(line.stretch_ref); if (!line || known.has(line.stretch_ref)) continue; // a file present twice is one stretch
     if (line.day >= today()) { waiting += 1; continue; }
     known.add(line.stretch_ref);
     fresh.push(line);
@@ -305,7 +305,7 @@ function archive(dir) {
   }
   if (fresh.length > 0 || !existing.manifest) writeFileSync(join(dir, "manifest.json"), `${JSON.stringify({ format: "worktrust-ai-evidence/1", collector_version: COLLECTOR, created: existing.manifest?.created ?? new Date().toISOString(), updated: new Date().toISOString(), clients: [...new Set(all.map((line) => line.client))].sort(), ...IDS, count: all.length, head: prev }, null, 1)}\n`);
   say();
-  say(`  ✓ ${fresh.length} new day-stretch${fresh.length === 1 ? "" : "es"} archived in ${dir}: it holds ${all.length}, the session hook measures ${rows.length - 1 - waiting} finished ones here now${key ? ", each day's root signed with this computer's device key" : ", unsigned (no device key on this computer)"}.`);
+  say(`  ✓ ${fresh.length} new day-stretch${fresh.length === 1 ? "" : "es"} archived in ${dir}: it holds ${all.length}, the session hook measures ${measured.size} finished ones here now${key ? ", each day's root signed with this computer's device key" : ", unsigned (no device key on this computer)"}.`);
   if (waiting > 0) say(`    ${waiting} of today wait for tomorrow's run: a day is archived once it is over.`);
   say("    Metadata only: clocks, counts, model names, a hash of each project's name. Nothing was sent.");
 }

package/session-databases.mjs

@@ -33,6 +33,7 @@ export const hermesSteered = (source) => (HERMES_DESK.has(source) ? "desk" : HER
 let sqlite;
 /** A database session's pseudo-file, `<client>:<database>#<session id>`, back into its parts. */
 const splitSession = (pseudo) => { const at = pseudo.lastIndexOf("#"); return { file: pseudo.slice(pseudo.indexOf(":") + 1, at), id: pseudo.slice(at + 1) }; };
+const isoOf = (value) => { const at = new Date(value); return Number.isFinite(at.getTime()) ? at.toISOString() : null; }; // null: that row is skipped, never the session (0.6.16, M2)
 const openDatabase = (file) => {
   if (sqlite === undefined) {
     // node:sqlite says it is experimental on some Node versions; that line is not the person's business inside a hook.
@@ -85,10 +86,10 @@ export function hermesLines(pseudo) {
     const out = [{ type: "meta", ...(typeof session.cwd === "string" ? { cwd: session.cwd } : {}), steered: hermesSteered(session.source) }];
     const lastAssistant = messages.map((m) => m.role).lastIndexOf("assistant");
     messages.forEach((message, i) => {
-      const timestamp = new Date(Number(message.timestamp) * 1000).toISOString();
+      const timestamp = isoOf(Number(message.timestamp) * 1000); if (!timestamp) return;
       if (message.role === "user") out.push({ type: "user", timestamp, message: { content: [{ type: "text" }] } });
       else if (message.role === "tool") out.push({ type: "user", timestamp, message: { content: [{ type: "tool_result" }] } });
-      else if (message.role === "assistant") out.push({ type: "assistant", timestamp, message: { model, ...(i === lastAssistant ? { usage: { input_tokens: Number(session.input_tokens) || 0, output_tokens: Number(session.output_tokens) || 0, cache_read_input_tokens: Number(session.cache_read_tokens) || 0, cache_creation_input_tokens: Number(session.cache_write_tokens) || 0 } } : {}), content: [] } });
+      else if (message.role === "assistant") out.push({ type: "assistant", timestamp, ...(i === lastAssistant ? { cumulative: true } : {}), message: { model, ...(i === lastAssistant ? { usage: { input_tokens: Number(session.input_tokens) || 0, output_tokens: Number(session.output_tokens) || 0, cache_read_input_tokens: Number(session.cache_read_tokens) || 0, cache_creation_input_tokens: Number(session.cache_write_tokens) || 0 } } : {}), content: [] } });
     });
     return out;
   } catch { return null; } finally { db.close(); }
@@ -146,16 +147,15 @@ export function gooseLines(pseudo) {
     const messages = db.prepare(`select role, created_timestamp as at,
       case when json_valid(content_json) then (select group_concat(json_extract(value, '$.type')) from json_each(content_json)) end as kinds
       from messages where session_id = ? order by created_timestamp, id`).all(id);
-    const ledger = db.prepare("select 1 from sqlite_master where type = 'table' and name = 'usage_ledger'").get()
-      ? db.prepare("select created_timestamp as at, model, input_tokens as input, output_tokens as output, cache_read_tokens as cache_read, cache_write_tokens as cache_write from usage_ledger where session_id = ? order by created_timestamp, id").all(id)
+    const ledger = db.prepare("select 1 from sqlite_master where type = 'table' and name = 'usage_ledger'").get() ? db.prepare("select created_timestamp as at, model, input_tokens as input, output_tokens as output, cache_read_tokens as cache_read, cache_write_tokens as cache_write from usage_ledger where session_id = ? order by created_timestamp, id").all(id)
       : null;
     const fallbackModel = cleanModel(session.model);
     const lines = messages.map((message) => {
       const kinds = new Set(String(message.kinds ?? "").split(","));
-      const timestamp = new Date(ms(message.at)).toISOString();
+      const timestamp = isoOf(ms(message.at)); if (!timestamp) return null;
       if (message.role === "user") return { type: "user", timestamp, message: { content: [{ type: kinds.has("toolResponse") ? "tool_result" : kinds.has("text") || kinds.has("image") ? "text" : "tool_result" }] } };
       return { type: "assistant", timestamp, at: ms(message.at), message: { model: fallbackModel, content: [] } };
-    });
+    }).filter(Boolean);
     const assistants = lines.filter((line) => line.type === "assistant");
     const usageOf = (row) => ({ input_tokens: Number(row.input) || 0, output_tokens: Number(row.output) || 0, cache_read_input_tokens: Number(row.cache_read) || 0, cache_creation_input_tokens: Number(row.cache_write) || 0 });
     const add = (line, usage) => { const was = line.message.usage; line.message.usage = was ? Object.fromEntries(Object.entries(usage).map(([key, n]) => [key, n + (was[key] ?? 0)])) : usage; };
@@ -165,7 +165,7 @@ export function gooseLines(pseudo) {
       if (!line) continue;
       add(line, usageOf(row));
       if (cleanModel(row.model)) line.message.model = cleanModel(row.model);
-    } else if (assistants.length) add(assistants.at(-1), usageOf(session));
+    } else if (assistants.length) { add(assistants.at(-1), usageOf(session)); assistants.at(-1).cumulative = true; } // the session's totals: sent as what they grew by
     for (const line of assistants) delete line.at;
     return [{ type: "meta", ...(typeof session.cwd === "string" ? { cwd: session.cwd } : {}), steered: gooseSteered(session.type) }, ...lines];
   } catch { return null; } finally { db.close(); }
@@ -212,11 +212,11 @@ export function opencodeLines(pseudo) {
       json_extract(data, '$.tokens.reasoning') as reasoning, json_extract(data, '$.tokens.cache.read') as cache_read, json_extract(data, '$.tokens.cache.write') as cache_write
       from message where session_id = ? order by time_created, id`).all(id);
     const lines = messages.map((message) => {
-      const timestamp = new Date(Number(message.at)).toISOString();
+      const timestamp = isoOf(Number(message.at)); if (!timestamp) return null;
       if (message.role === "user") return { type: "user", timestamp, message: { content: [{ type: "text" }] } };
       const counted = message.input !== null || message.output !== null;
       return { type: "assistant", timestamp, message: { model: cleanModel(message.model), ...(counted ? { usage: { input_tokens: Number(message.input) || 0, output_tokens: (Number(message.output) || 0) + (Number(message.reasoning) || 0), cache_read_input_tokens: Number(message.cache_read) || 0, cache_creation_input_tokens: Number(message.cache_write) || 0 } } : {}), content: [] } };
-    });
+    }).filter(Boolean);
     return [{ type: "meta", ...(typeof session.cwd === "string" ? { cwd: session.cwd } : {}) }, ...lines];
   } catch { return null; } finally { db.close(); }
 }
@@ -349,7 +349,7 @@ export function cursorLines(pseudo) {
     const model = cleanModel(chat?.model);
     const lines = [];
     for (const bubble of bubbles.sort((a, b) => String(a.at).localeCompare(String(b.at)))) {
-      const timestamp = new Date(bubble.at).toISOString();
+      const timestamp = isoOf(bubble.at); if (!timestamp) continue;
       if (Number(bubble.type) === 1) lines.push({ type: "user", timestamp, message: { content: [{ type: "text" }] } });
       else if (Number(bubble.type) === 2) {
         const usage = Number(bubble.input) || Number(bubble.output) ? { usage: { input_tokens: Number(bubble.input) || 0, output_tokens: Number(bubble.output) || 0 } } : {};

package/setup-mcp.mjs

@@ -19,7 +19,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync
 import { spawnSync } from "node:child_process";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
-import { placeUnder, takeOut } from "./config-edits.mjs";
+import { isWorkTrustDoor, placeUnder, takeOut } from "./config-edits.mjs";
 
 const args = process.argv.slice(2);
 const value = (name) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : undefined; };
@@ -39,7 +39,7 @@ function fromClaude() {
   try {
     const config = JSON.parse(readFileSync(join(homedir(), ".claude.json"), "utf8"));
     const found = [];
-    const walk = (node) => { if (!node || typeof node !== "object") return; if (typeof node.url === "string" && node.url.includes("/api/mcp")) { const auth = node.headers?.Authorization ?? node.headers?.authorization ?? ""; if (auth.startsWith("Bearer ")) found.push({ url: node.url, token: auth.slice(7) }); } for (const child of Object.values(node)) walk(child); };
+    const walk = (node) => { if (!node || typeof node !== "object") return; if (typeof node.url === "string" && isWorkTrustDoor(node.url)) { const auth = node.headers?.Authorization ?? node.headers?.authorization ?? ""; if (auth.startsWith("Bearer ")) found.push({ url: node.url, token: auth.slice(7) }); } for (const child of Object.values(node)) walk(child); };
     walk(config); return found[0] ?? null;
   } catch { return null; }
 }
@@ -54,7 +54,7 @@ const discovered = fromClaude();
 function directClaudeEntries() {
   try {
     const config = JSON.parse(readFileSync(join(homedir(), ".claude.json"), "utf8"));
-    const door = (server) => typeof server?.url === "string" && /\/api\/mcp\b/.test(server.url) && /worktrust/i.test(new URL(server.url).host);
+    const door = (server) => typeof server?.url === "string" && isWorkTrustDoor(server.url);
     const entries = Object.entries(config.mcpServers ?? {}).filter(([, server]) => door(server)).map(([name]) => ({ name, scope: "user", dir: null }));
     for (const [dir, project] of Object.entries(config.projects ?? {})) for (const [name, server] of Object.entries(project?.mcpServers ?? {})) if (door(server)) entries.push({ name, scope: "local", dir });
     const bridged = Object.values(config.mcpServers ?? {}).some((server) => Array.isArray(server?.args) && server.args.includes(BRIDGE));

package/transcript-readers.mjs

@@ -38,7 +38,10 @@ import { fileURLToPath } from "node:url";
  * 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.
  */
-export const CODEX_ROLLOUT = /(^|\/)rollout-\d{4}-\d{2}-\d{2}T[\d-]+-[0-9a-f-]{36}\.jsonl$/;
+// Either separator (0.6.16, audit H4): on Windows a path reads C:\Users\…\rollout-….jsonl, and a pattern of `/` alone matched none.
+export const CODEX_ROLLOUT = /(^|[\\/])rollout-\d{4}-\d{2}-\d{2}T[\d-]+-[0-9a-f-]{36}\.jsonl$/;
+/** A rollout's thread id: its file's name without .jsonl, split on either separator. */
+export const codexIdOf = (file) => String(file).split(/[\\/]/).at(-1).replace(/\.jsonl$/, "");
 export const CODEX_HARNESS_TURN = /^\s*<[a-z][a-z_]*[\s>]/i;
 export 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"));
 export const codexToolInput = (name, raw) => {
@@ -134,7 +137,9 @@ export function codexCwd(file) {
  * `thinking` is never read. No usage block is made up: such a stretch is sent without tokens.
  * A step written twice (RUNNING, then DONE) is read once, on its step_index.
  */
-export const ANTIGRAVITY_TRANSCRIPT = /(^|\/)brain\/[^/]+\/\.system_generated\/logs\/transcript\.jsonl$/;
+export const ANTIGRAVITY_TRANSCRIPT = /(^|[\\/])brain[\\/][^\\/]+[\\/]\.system_generated[\\/]logs[\\/]transcript\.jsonl$/; // either separator (0.6.16, H4)
+/** A transcript's conversation id: the folder under brain/, split on either separator. */
+export const antigravityIdOf = (file) => String(file).split(/[\\/]/).at(-4);
 const ANTIGRAVITY_SKIPPED = new Set(["CONVERSATION_HISTORY", "CHECKPOINT", "SYSTEM_MESSAGE", "EPHEMERAL_MESSAGE"]);
 /** A model name as a client names it, or null: the hook's modelName is the only one, and a name is all it may be. */
 export const cleanModel = (name) => (typeof name === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/ -]{0,63}$/.test(name.trim()) ? name.trim() : null);

package/worktrust.mjs

@@ -69,7 +69,7 @@ const command = args.find((arg, at) => !arg.startsWith("--") && !(at > 0 && VALU
 const flag = (name) => { const at = args.indexOf(`--${name}`); return at >= 0 ? args[at + 1] : undefined; };
 const has = (name) => args.includes(`--${name}`);
 /** This CLI's version, said to the door so the app can tell which computer runs an old one (check-cli-package holds it equal to package.json). */
-const CLI_VERSION = "0.6.14";
+const CLI_VERSION = "0.6.16";
 const ORIGIN = (flag("origin") ?? process.env.WORKTRUST_ORIGIN ?? "https://app.worktrust.io").replace(/\/$/, "");
 const MCP = flag("url") ?? process.env.WORKTRUST_MCP_URL ?? `${ORIGIN}/api/mcp`;
 const HOME_DIR = join(homedir(), ".worktrust");
@@ -81,6 +81,8 @@ const downloaded = (name) => (IMPORTED.has(name) ? name : `${name}.download.mjs`
 const BUNDLED = SCRIPTS.every((name) => existsSync(join(HERE, name)));
 const PLACEHOLDER = `wt_${"0".repeat(43)}`;
 const say = (line = "") => process.stdout.write(`${line}\n`);
+// A reader that closed the pipe (`worktrust status | head`) wants no more: stop quietly, never an EPIPE stack (0.6.16, audit L4).
+process.stdout.on("error", (error) => { if (error?.code === "EPIPE") process.exit(0); throw error; });
 const fail = (line) => { process.stderr.write(`worktrust: ${line}\n`); process.exit(1); };
 const OS = { darwin: "macos", win32: "windows", linux: "linux" }[platform()] ?? "other";
 const OS_NAME = { macos: "macOS", windows: "Windows", linux: "Linux", other: "this system" }[OS];
@@ -576,7 +578,8 @@ async function connect() {
   say(`    + ${join(HOME_DIR, "log-session.mjs")} and ${join(HOME_DIR, "count-behaviour.mjs")}${BUNDLED ? " (from this package, not updated from the network)" : ""}`);
   say(`    + ${join(homedir(), ".claude", "settings.json")} → SessionStart, SessionEnd and PreCompact run it`);
   say();
-  say("  Sent to WorkTrust afterwards: durations, token counts, model names, a layer keyword, counts.");
+  say("  Sent to WorkTrust afterwards: durations, token counts, model names, a layer keyword, counts,");
+  say("  and, to match the work to GitHub, the repository's owner/name and the commit hashes.");
   say("  Never sent: prompts, answers, code, file paths, commit messages.");
   say();
   if (has("dry-run")) { say("  Dry run: nothing was written and nothing was sent."); return; }
@@ -634,8 +637,8 @@ async function offerHistory(paths, token, devicePem, url = MCP) {
   let found = null;
   try { found = JSON.parse(counted.out.trim().split("\n").pop()); } catch { /* no line: nothing to offer */ }
   say();
-  if (!found?.sessions) { say("  No earlier Claude Code, Codex or Antigravity sessions on this computer to send."); return; }
-  say(`  This computer holds ${found.sessions} earlier Claude Code / Codex / Antigravity sessions · ${found.hours} measured hours · ${found.first} … ${found.last}.`);
+  if (!found?.sessions) { say("  Your AI apps hold no earlier sessions on this computer to send."); return; }
+  say(`  This computer holds ${found.sessions} earlier sessions of your AI apps · ${found.hours} measured hours · ${found.first} … ${found.last}.`);
   if (has("dry-run")) { say("  Dry run: nothing was sent."); return; }
   if (!has("history") && !(await ask("Send these as history (hours and tokens per day; never text)?", false))) { say("  Not sent. Send them later with: npx worktrust@latest history"); return; }
   const sent = await run(paths["log-session.mjs"], ["--history"], token, true, env);