worktrust 0.6.15 → 0.6.17

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
@@ -79,6 +79,8 @@ yourself run a command that sends. See [Keep your history](#keep-your-history).
 
 ```
 npx worktrust@latest history       send this computer's earlier sessions later (asks first)
+npx worktrust@latest history --rebuild   re-measure them with the current rules; WorkTrust replaces this computer's
+                                   earlier lines day by day, never counting a day twice (shows the plan, 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@latest status        what is coupled here
@@ -179,6 +181,36 @@ and counts, exactly as the session hook reads it.
   [worktrust.io/preserve](https://worktrust.io/preserve) is this package plus a guideline, for teams
   that want the same record without WorkTrust.
 
+## Rebuild the history
+
+A newer version of this command measures a session differently from an older one: what the seconds were (the model
+answering, tools running, your own turns, pauses), your own turns rather than every message, tokens with the cache,
+and more AI apps (Cursor, Copilot, Hermes, Goose, OpenCode, OpenClaw, Codex, Antigravity). Lines an earlier version
+sent stand as they were measured then, and sending the sessions again would count those days twice: an old line
+does not name its stretch, so WorkTrust cannot tell it from the one that arrives.
+
+`npx worktrust@latest history --rebuild` re-measures every session still on this computer with the current rules and
+sends them with one difference: WorkTrust **replaces** this computer's earlier lines, day by day.
+
+- **What it does.** It shows the plan first: per AI app, the days and the measured hours it would send, and the first
+  and last day. It asks once; Enter is No. `--dry-run` shows the plan and stops. Nothing is sent before a typed `y`.
+  For every day and AI app it carries, WorkTrust withdraws this computer's earlier lines (sent by this key or by an
+  earlier key of the same computer, live or as history), each with a correction row that says why, and then stores the
+  re-measured lines. A line that arrives unchanged is kept as it is. A day is counted once, and the same rebuild sent
+  twice changes nothing.
+- **What it never does.** A replaced line is withdrawn and kept, never deleted: it stays in your record and the record shows
+  each replacement; deleting your account still removes all of it. Never touched: another computer's lines, what a web
+  connector (Claude or ChatGPT on the web) brought in, an AI app the batch does not carry, a day it does not carry, a line
+  you made private, a line less than 48 hours old (the session hook's own window), and a line received in the last 12
+  hours (the batches of one run never replace each other). It sends what `history` sends and nothing more: durations,
+  token counts, model names, a layer keyword, counts; never text.
+- **Only from this computer's own key.** A connector (an AI signed in on the web) cannot ask for a rebuild; WorkTrust
+  refuses it at the door.
+- **Offered once by `update`.** When this computer's earlier lines were made by an earlier version (the copy in
+  `~/.worktrust` says which), `npx worktrust@latest update` says so in plain words and offers the rebuild; Enter is No,
+  and the same version updated again offers nothing. The command cannot read your record, so it is an offer, not a
+  finding.
+
 ## Where the key lives, and why it only works here
 
 The key is kept in **one file only you can read**: `~/.worktrust/key.json` (mode 600, in a folder of
@@ -202,11 +234,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

@@ -23,7 +23,8 @@
  *   node log-session.mjs --uninstall [--purge] take it out again (--purge also deletes the copies)
  *   node log-session.mjs --dry-run            show what the current transcripts would send
  *   node log-session.mjs --history [--dry-run] send the months already on this machine, as HISTORY
- *   node log-session.mjs --history --summary   one JSON line: sessions, hours, first and last month (sends nothing)
+ *   node log-session.mjs --history --rebuild   the same, re-measured: the door REPLACES this computer's earlier lines, day by day
+ *   node log-session.mjs --history --summary   one JSON line: sessions, hours, first and last month, per client (sends nothing)
  *   (as a hook)                                reads the hook's JSON on stdin, logs, exits
  *   (from Codex)                               notify = ["node", "~/.worktrust/log-session.mjs", "--codex-notify"]
  *                                              in ~/.codex/config.toml: Codex calls it at every turn's end and
@@ -38,8 +39,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
@@ -61,11 +62,9 @@ import { fileURLToPath } from "node:url";
 import { createHash, randomBytes, sign as cryptoSign } from "node:crypto";
 
 const args = process.argv.slice(2);
-const flag = (name) => args.includes(`--${name}`);
+const flag = (name) => args.includes(`--${name}`), value = (name) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : undefined; }, DRY = flag("dry-run");
 // Exit once stdout is written: to a pipe it is asynchronous and process.exit drops what is queued (0.6.13 cut --archive-lines).
 const exitFlushed = (code) => new Promise((resolve) => process.stdout.write("", resolve)).then(() => process.exit(code));
-const value = (name) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : undefined; };
-const DRY = flag("dry-run");
 
 /**
  * THE OTHER HALF OF A SESSION: HOW IT WAS ASKED.
@@ -136,8 +135,7 @@ const DAY_SECONDS = 86400;
 const TOOL_CAP = 1800;
 /** Tools whose result waits for the person: the gap to it is the person's time. Names only; nothing of the call is read. */
 const WAITS_FOR_PERSON = new Set(["AskUserQuestion", "ExitPlanMode"]);
-const AGENT_RUNS_MAX = 10000;
-const AGENT_SECONDS_MAX = 2592000;
+const AGENT_RUNS_MAX = 10000, AGENT_SECONDS_MAX = 2592000;
 
 /**
  * WHEN THE HOOK RUNS. SessionEnd alone was a bet that sessions end, and a session that stays open
@@ -151,8 +149,7 @@ const AGENT_SECONDS_MAX = 2592000;
 const HOOK_EVENTS = ["SessionEnd", "SessionStart", "PreCompact"];
 
 const STATE = join(homedir(), ".worktrust", "sessions.json");
-const readState = () => { try { return JSON.parse(readFileSync(STATE, "utf8")); } catch { return {}; } };
-const writeState = (state) => { mkdirSync(dirname(STATE), { recursive: true }); writeFileSync(STATE, JSON.stringify(state, null, 1)); };
+const readState = () => { try { return JSON.parse(readFileSync(STATE, "utf8")); } catch { return {}; } }, writeState = (state) => { mkdirSync(dirname(STATE), { recursive: true }); writeFileSync(STATE, JSON.stringify(state, null, 1)); };
 /**
  * THE FLOORS (owner, 2026-10-04: "history is never sent silently"). `__from` is the moment this
  * computer was coupled: the hook sends nothing measured before it, so a fresh coupling (or one after
@@ -209,9 +206,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 +234,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 +259,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 +363,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 +461,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 +521,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. */
@@ -574,7 +577,7 @@ function payloadFor(stretch) {
  * exactly what landed. `announce` because one caller is a person watching a terminal and the other
  * is a hook holding a session's exit open.
  */
-async function sendHistory(door, entries, announce = false) {
+async function sendHistory(door, entries, announce = false, rebuild = false) {
   let accepted = 0;
   // A Codex entry goes through Codex's own coupling where one exists (see codexDoor), the rest
   // through the door given: the record files a line under the coupling that sent it. Antigravity's
@@ -584,9 +587,10 @@ async function sendHistory(door, entries, announce = false) {
   if (group.length === 0 || !target) continue;
   for (let i = 0; i < group.length; i += 200) {
     const batch = group.slice(i, i + 200);
-    // History carries no shas: an imported line forms no session, and the join is the live route's.
-    const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "import_history", arguments: { entries: batch.map((entry) => { const { commits, ...rest } = entry; void commits; return rest; }) } } });
-    const response = await fetch(target.url, { method: "POST", headers: { "content-type": "application/json", accept: "application/json, text/event-stream", authorization: `Bearer ${target.token}`, ...clientOf(source), ...proofFor(target.url, body) }, body });
+    // History carries no shas: an imported line forms no session, and the join is the live route's. REBUILD (owner, 2026-10-07): `rebuild: true`
+    // tells the door to replace this computer's earlier lines on the days and for the client the batch carries, and every group names its client.
+    const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "import_history", arguments: { ...(rebuild ? { rebuild: true } : {}), entries: batch.map((entry) => { const { commits, ...rest } = entry; void commits; return rest; }) } } });
+    const response = await fetch(target.url, { method: "POST", headers: { "content-type": "application/json", accept: "application/json, text/event-stream", authorization: `Bearer ${target.token}`, ...clientOf(source, rebuild), ...proofFor(target.url, body) }, body });
     const text = await response.text();
     if (announce) console.log(`batch ${Math.floor(i / 200) + 1}: ${response.status} ${text.slice(0, 200).replace(/\\n/g, " ")}`);
     if (!response.ok) break;
@@ -610,7 +614,7 @@ const proofFor = (url, body) => {
  * on this computer, and the door names a coupling's clients by the user-agent it hears (mcp_identify's
  * agents_seen). An Antigravity line names Antigravity: the product name, nothing of the work.
  */
-const clientOf = (source) => (source === "antigravity" || DATABASE_CLIENTS.includes(source) ? { "user-agent": `${source}/hook (worktrust-hook)` } : {});
+const clientOf = (source, always = false) => (always || source === "antigravity" || DATABASE_CLIENTS.includes(source) ? { "user-agent": `${source ?? "claude"}/hook (worktrust-hook)` } : {});
 
 async function send(door, payload) {
   const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "log_work", arguments: payload } });
@@ -668,7 +672,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. */
@@ -863,17 +868,18 @@ if (flag("history")) {
   const entries = historyEntries(historyFloor);
   const hours = entries.reduce((sum, entry) => sum + (entry.seconds ?? 0), 0) / 3600;
   const months = [...new Set(entries.map((entry) => entry.at.slice(0, 7)))].sort();
-  // ONE LINE FOR `npx worktrust` TO ASK WITH (2026-10-03): sessions, hours, first and last month; nothing sent.
-  if (flag("summary")) { console.log(JSON.stringify({ sessions: new Set(entries.map((entry) => entryFile.get(entry).file)).size, hours: Math.round(hours * 10) / 10, first: months[0] ?? null, last: months.at(-1) ?? null })); await exitFlushed(0); }
-  console.log(`${entries.length} day-stretches · ${hours.toFixed(1)} measured hours · ${months.join(", ")}`);
+  // ONE LINE FOR `npx worktrust` TO ASK WITH (2026-10-03): sessions, hours, first and last month; per client its days and hours (the rebuild's plan, 2026-10-07); nothing sent.
+  const clients = [...entries.reduce((map, entry) => { const client = entrySource.get(entry) ?? "claude", row = map.get(client) ?? { client, days: new Set(), seconds: 0 }; row.days.add(entry.at.slice(0, 10)); row.seconds += entry.seconds ?? 0; return map.set(client, row); }, new Map()).values()].map((row) => ({ client: row.client, days: row.days.size, hours: Math.round(row.seconds / 360) / 10, first: [...row.days].sort()[0], last: [...row.days].sort().at(-1) }));
+  if (flag("summary")) { console.log(JSON.stringify({ sessions: new Set(entries.map((entry) => entryFile.get(entry).file)).size, hours: Math.round(hours * 10) / 10, first: months[0] ?? null, last: months.at(-1) ?? null, clients })); await exitFlushed(0); }
+  console.log(`${entries.length} day-stretches · ${hours.toFixed(1)} measured hours · ${months.join(", ")}${flag("rebuild") ? " · rebuild: this computer's earlier lines for these days and clients are replaced at the door" : ""}`);
   if (DRY) {
     // One example in full: the shape is the argument for trusting it, and a summary hides it.
     if (entries[0]) console.log(`\nthe oldest of them, in full:\n${JSON.stringify(entries[0], null, 1)}`);
-    console.log("\ndry run — nothing sent. Add --history without --dry-run to import them.");
+    console.log(`\ndry run — nothing sent. Add --history${flag("rebuild") ? " --rebuild" : ""} without --dry-run to ${flag("rebuild") ? "rebuild" : "import"} them.`);
     await exitFlushed(0);
   }
   // A batch the door refused is a failure the caller must see, not a quiet zero.
-  await exitFlushed((await sendHistory(door, entries, true)) === entries.length ? 0 : 1);
+  await exitFlushed((await sendHistory(door, entries, true, flag("rebuild"))) === entries.length ? 0 : 1);
 }
 
 const input = hookInput();
@@ -901,51 +907,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.15",
+  "version": "0.6.17",
   "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/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

@@ -10,6 +10,8 @@
  *   npx worktrust@latest connect               couple again, also on a computer already coupled
  *   npx worktrust@latest update                this computer onto the newest CLI, same key, no new pairing
  *   npx worktrust@latest history               send this computer's earlier sessions as history (asks first)
+ *   npx worktrust@latest history --rebuild     re-measure them with the current rules; WorkTrust replaces this computer's
+ *                                              earlier lines day by day, never counting a day twice (shows the plan, asks first)
  *   npx worktrust@latest disconnect            show what comes out, ask, take it out again
  *   npx worktrust@latest status                what is coupled here
  *   npx worktrust@latest preserve              how long each AI app here keeps its sessions (--apply keeps them,
@@ -69,7 +71,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.15";
+const CLI_VERSION = "0.6.17";
 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 +83,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];
@@ -530,6 +534,7 @@ async function update() {
   if (has("dry-run")) { say("  Dry run: nothing was written and nothing was sent."); return; }
   if (!(await ask("Continue?"))) { say("  Stopped. Nothing was written."); return; }
   ensureHome();
+  const previousVersion = stableVersion();
   copyFileSync(fileURLToPath(import.meta.url), STABLE);
   say(`  ✓ ${STABLE} is now ${CLI_VERSION}`);
   // Out first, then in: an app that held a key of its own (a hand-made entry) moves onto the bridge.
@@ -540,6 +545,7 @@ async function update() {
   // Codex installed since, or a No said at connect: the one question, asked again (or "already set").
   await offerCodex();
   await offerAntigravity();
+  await offerRebuild(previousVersion, paths, key);
   say();
   say("  Done. Quit your AI apps completely and open them again; the CLI version shows in WorkTrust");
   say("  under Sources → CLI once one of them has spoken. A key an app held by hand still works until you end it there.");
@@ -576,7 +582,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; }
@@ -628,24 +635,52 @@ async function connect() {
  * Enter, --yes and a closed terminal all mean No; `--history` says yes in advance. What goes is hours
  * and tokens per day, filed as history (never verified hours, never text).
  */
-async function offerHistory(paths, token, devicePem, url = MCP) {
+async function offerHistory(paths, token, devicePem, url = MCP, rebuild = false) {
   const env = { WORKTRUST_MCP_URL: url, ...(devicePem ? { WORKTRUST_DEVICE_KEY: devicePem } : {}) };
   const counted = await run(paths["log-session.mjs"], ["--history", "--dry-run", "--summary"], token, true, env);
   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(rebuild ? "  Your AI apps hold no earlier sessions on this computer to re-measure." : "  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}.`);
+  // REBUILD (owner, 2026-10-07): the plan per AI app, in days and hours, and what it replaces, before the one question. Enter is No.
+  if (rebuild) {
+    for (const row of found.clients ?? []) say(`    ${row.client.padEnd(12)} ${String(row.days).padStart(4)} days  ${String(row.hours).padStart(7)} h   ${row.first} … ${row.last}`);
+    say("  Re-measured with the current rules (what the seconds were, your own turns, tokens with the cache, every AI app above).");
+    say("  WorkTrust REPLACES this computer's earlier lines for those days and apps: each earlier line is withdrawn and kept,");
+    say("  never deleted, so a day is counted once. Other computers, web sources and days not listed are not touched.");
+  }
   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);
-  say(sent.code === 0 ? "  ✓ Sent as history. It shows in WorkTrust as earlier work, never as verified hours." : "  Not all of it arrived. Run npx worktrust@latest history again: a line already received is kept once.");
+  if (!has("history") && !(rebuild ? await ask("Rebuild the history (replaces this computer's earlier lines for these days)?", false) : await ask("Send these as history (hours and tokens per day; never text)?", false))) { say(rebuild ? "  Not sent. Rebuild later with: npx worktrust@latest history --rebuild" : "  Not sent. Send them later with: npx worktrust@latest history"); return; }
+  const sent = await run(paths["log-session.mjs"], ["--history", ...(rebuild ? ["--rebuild"] : [])], token, true, env);
+  if (rebuild) say(sent.code === 0 ? "  ✓ Rebuilt. This computer's earlier lines for those days were replaced; the record shows each replacement." : "  Not all of it arrived. Run npx worktrust@latest history --rebuild again: a day already rebuilt is counted once.");
+  else say(sent.code === 0 ? "  ✓ Sent as history. It shows in WorkTrust as earlier work, never as verified hours." : "  Not all of it arrived. Run npx worktrust@latest history again: a line already received is kept once.");
+}
+
+/** The version stamped in the stable copy in ~/.worktrust, the CLI this computer ran before an update; null without one. */
+const stableVersion = () => { try { return /const CLI_VERSION = "([^"]+)";/.exec(readFileSync(STABLE, "utf8"))?.[1] ?? null; } catch { return null; } };
+
+/**
+ * OFFERED ONCE, BY `update`, IN PLAIN WORDS (owner, 2026-10-07): when the computer's earlier lines were made by an earlier CLI
+ * (the version the stable copy carried before this update). The CLI cannot read the record, so it is an offer, not a
+ * finding: the plan is shown and the question asked by the same path as `history --rebuild`; Enter is No. The same
+ * version updated again offers nothing.
+ */
+async function offerRebuild(previousVersion, paths, key) {
+  if (!previousVersion || previousVersion === CLI_VERSION) return;
+  say();
+  say(`  This computer's earlier lines in WorkTrust were measured by worktrust ${previousVersion}. Version ${CLI_VERSION} measures`);
+  say("  differently (what the seconds were, your own turns, tokens with the cache, more AI apps). You can re-measure the");
+  say("  sessions still on this computer and have WorkTrust replace this computer's earlier lines, day by day, never counting");
+  say("  a day twice. Later: npx worktrust@latest history --rebuild");
+  if (!(await ask("Show the plan and rebuild now?", false))) { say("  Not now."); return; }
+  await offerHistory(paths, key.token, key.device ?? null, key.url, true);
 }
 
 async function history() {
   const key = await freshKey();
   if (!key) fail("this computer is not coupled through the key file. Run npx worktrust first.");
-  await offerHistory(await scripts(), key.token, key.device ?? null, key.url);
+  await offerHistory(await scripts(), key.token, key.device ?? null, key.url, has("rebuild"));
 }
 
 /**
@@ -840,6 +875,8 @@ function help() {
   say("    --replace            yes in advance to coupling a computer that is already coupled");
   say("  worktrust update       this computer onto the newest CLI: same key, no new pairing");
   say("  worktrust history      send this computer's earlier sessions as history (asks first)");
+  say("    --rebuild            re-measure them with the current rules; WorkTrust replaces this computer's earlier lines,");
+  say("                         day by day, never counting a day twice (shows the plan per AI app, asks first; --dry-run: the plan only)");
   say("  worktrust disconnect   take WorkTrust out of every AI app here (asks first)");
   say("  worktrust status       what is coupled here");
   say("  worktrust preserve     keep your AI history: the report, then the settings and a local archive, each on your yes");