worktrust 0.6.16 → 0.6.18

package/README.md

@@ -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
@@ -143,8 +145,10 @@ nothing it does not:
 | `day`, `started_at`, `ended_at` | the day, and when the measured stretch began and ended |
 | `seconds` | measured time: every gap between stamped events up to five minutes |
 | `model_seconds`, `tool_seconds`, `human_seconds`, `idle_seconds` | what those seconds were: the model answering, tools or an agent run, your own turns, and what a cap cut off |
-| `tokens_in`, `tokens_out`, `tokens_cache_read`, `tokens_cache_write` | token counts, when the app records them |
+| `tokens_in`, `tokens_out`, `tokens_cache_read`, `tokens_cache_write` | token counts, when the app records them (one answer counted once, however many lines the app wrote it in) |
 | `agent_runs`, `agent_seconds`, `agent_peak` | subagents: how many ran, their own time, the most open at once (never added to `seconds`) |
+| `interrupts`, `steers` | how often you stopped the agent mid-answer, and how often your message arrived while it was still mid-task (counts, never the words) |
+| `utc_offset` | your computer's offset from UTC when the stretch began, such as +02:00, so a working day reads in your own local time |
 | `model` | the model's name as the app reported it |
 | `kind`, `layer`, `layers` | the kind of work (built, changed, researched) and the area it touched (front end, back end, data …), as the session hook names them |
 | `exchanges` | how many times you and the model took turns |
@@ -179,6 +183,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
@@ -205,7 +239,7 @@ 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, 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** | 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). |
+| **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`, `interrupts`, `steers`), when it began and ended and your computer's offset from UTC (`started_at`, `at`, `utc_offset`), 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/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
@@ -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
@@ -345,22 +342,45 @@ function stretchesOf(file, since) {
   }
   if (messages.length === 0) return [];
   messages.sort((a, b) => a.at - b.at);
+  const byDay = byDayOf(messages);
+  const agents = agentsByDay(file, since);
+  return [...byDay.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([day, ofDay]) => { const stretch = measure(cwd, ofDay); return stretch && { ...stretch, ref: stretchRef(file, day), steered, agents: agents.get(day) ?? null }; }).filter(Boolean);
+}
+
+/**
+ * DAYS SPLIT ON THE CLOCK, NOTHING LOST AT MIDNIGHT (0.6.18, audit C14). A stretch is one session's UTC day, and the gap
+ * between a day's last message and the next day's first belonged to neither, so a run through the night lost one gap
+ * per midnight. A day whose first message follows the last one within the tool cap now opens with a BRIDGE: the message
+ * before it, carrying no tokens, no model and no turn, so the gap that crosses midnight is counted once, on the day it
+ * ends, under the same caps as any other.
+ * Messages must arrive sorted.
+ */
+function byDayOf(messages) {
   const byDay = new Map();
+  let prev = null;
   for (const message of messages) {
     const day = new Date(message.at).toISOString().slice(0, 10);
-    if (!byDay.has(day)) byDay.set(day, []);
+    // Only a gap the work could have run through (within the tool cap): a session resumed the next morning opens its day as it always did.
+    if (!byDay.has(day)) byDay.set(day, prev && message.at - prev.at <= TOOL_CAP * 1000 ? [{ ...prev, usage: null, model: null, cumulative: false, bridge: true }] : []);
     byDay.get(day).push(message);
+    prev = message;
   }
-  const agents = agentsByDay(file, since);
-  return [...byDay.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([day, ofDay]) => { const stretch = measure(cwd, ofDay); return stretch && { ...stretch, ref: stretchRef(file, day), steered, agents: agents.get(day) ?? null }; }).filter(Boolean);
+  return byDay;
 }
+/** The first message a day really holds (a bridge is the day before's). */
+const firstOf = (messages) => (messages.find((message) => !message.bridge) ?? messages[0]).at;
+/** The computer's offset from UTC at a moment, as +02:00: what the owner's mirror needs to read a working day in local time. */
+const offsetAt = (ms) => { const minutes = -new Date(ms).getTimezoneOffset(), abs = Math.abs(minutes); return `${minutes < 0 ? "-" : "+"}${String(Math.floor(abs / 60)).padStart(2, "0")}:${String(abs % 60).padStart(2, "0")}`; };
+/** Claude Code's own line when the person stops the agent mid-answer (Esc), read for its marker only. */
+const INTERRUPTED = /^\[Request interrupted by user/;
+const textOf = (content) => (typeof content === "string" ? content : Array.isArray(content) ? content.map((block) => (block && typeof block.text === "string" ? block.text : "")).join("") : "");
 
 /** One transcript line as the measure reads it: the clock, the role, what KIND of message it is (for the layers), its counts. */
 const messageOf = (line, at) => {
   const content = line.message?.content ?? null;
   const blocks = Array.isArray(content) ? content : [];
   return {
-    at, type: line.type, usage: line.message?.usage ?? null, model: line.message?.model ?? null, meta: line.isMeta === true, content,
+    at, type: line.type, usage: line.message?.usage ?? null, model: line.message?.model ?? null, messageId: typeof line.message?.id === "string" ? line.message.id : null, meta: line.isMeta === true, content,
     // A tool's answer comes back on the user role; a line a reader marks `agentic` is an agent run (Copilot's asked → completed).
     kind: line.type === "assistant" ? "assistant" : blocks.some((block) => block && block.type === "tool_result") ? "tool_result" : "user",
     toolUse: line.type === "assistant" && blocks.some((block) => block && block.type === "tool_use"),
@@ -459,12 +479,22 @@ function measure(cwd, messages) {
   const models = new Map();
   let exchanges = 0;
   for (const message of messages) {
-    if (message.type === "user" && !message.meta && isHumanTurn(message.content)) exchanges += 1;
+    if (message.type === "user" && !message.meta && !message.bridge && isHumanTurn(message.content)) exchanges += 1;
     if (message.model) models.set(message.model, (models.get(message.model) ?? 0) + 1);
   }
   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, cumulative: messages.some((message) => message.cumulative), exchanges, model, from: messages[0].at, to: messages[messages.length - 1].at };
+  // HOW THE PERSON STEERED (owner, 2026-10-08): how often they stopped the agent (Claude Code's interruption line), and how
+  // often their next turn arrived while the agent was still mid-task (right after a tool call or its result). Counts only.
+  let interrupts = 0, steers = 0;
+  for (let i = 1; i < messages.length; i += 1) {
+    const message = messages[i], prev = messages[i - 1];
+    if (message.bridge || message.type !== "user" || message.meta || message.kind === "tool_result") continue;
+    if (INTERRUPTED.test(textOf(message.content).trim())) interrupts += 1;
+    else if (isHumanTurn(message.content) && (prev.kind === "tool_result" || prev.toolUse)) steers += 1;
+  }
+  const from = firstOf(messages);
+  return { cwd, seconds: measured, layers: measured !== null ? timeLayers(messages) : null, ...tokens, cumulative: messages.some((message) => message.cumulative), exchanges, interrupts, steers, model, from, to: messages[messages.length - 1].at, offset: offsetAt(from) };
 }
 
 /**
@@ -511,9 +541,14 @@ function usageShapeKnown(usage) {
 }
 function tokensOf(messages) {
   let tokensIn = 0, tokensOut = 0, cacheRead = 0, cacheWrite = 0, counted = 0, shapeKnown = true;
+  // ONE ANSWER, ONE USAGE (0.6.18): Claude Code writes an answer as a line per content block (thinking, text, each tool
+  // call), every one repeating the answer's usage; summed per line, a real session read 2.6 times its output tokens. An
+  // answer with an id is counted once; a line without one (Codex's token events) is its own.
+  const seen = new Set();
   for (const message of messages) {
     const usage = message.usage;
     if (!usage) continue;
+    if (message.messageId) { if (seen.has(message.messageId)) continue; seen.add(message.messageId); }
     if (!usageShapeKnown(usage)) { shapeKnown = false; break; }
     counted += 1;
     tokensIn += (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
@@ -568,6 +603,10 @@ function payloadFor(stretch) {
     // THE LAYERS (2026-10-06), only on a measured stretch, each bounded by a day: what the seconds were. `seconds` above is untouched.
     ...(stretch.seconds !== null && stretch.layers ? { model_seconds: Math.min(DAY_SECONDS, stretch.layers.model), tool_seconds: Math.min(DAY_SECONDS, stretch.layers.tool), human_seconds: Math.min(DAY_SECONDS, stretch.layers.human), idle_seconds: Math.min(DAY_SECONDS, stretch.layers.idle) } : {}),
     // THE SUBAGENTS, as agent metadata beside the day: runs, their own seconds, the peak open at once. Never in `seconds`.
+    // WHEN AND HOW (0.6.18): the stretch's first moment and the computer's UTC offset then; the person's interruptions and mid-task turns, counts only.
+    started_at: new Date(stretch.from).toISOString(), utc_offset: stretch.offset,
+    ...(stretch.interrupts > 0 ? { interrupts: Math.min(10000, stretch.interrupts) } : {}),
+    ...(stretch.steers > 0 ? { steers: Math.min(10000, stretch.steers) } : {}),
     ...(stretch.agents && stretch.agents.runs > 0 ? { agent_runs: Math.min(AGENT_RUNS_MAX, stretch.agents.runs), agent_seconds: Math.min(AGENT_SECONDS_MAX, stretch.agents.seconds), agent_peak: Math.min(AGENT_RUNS_MAX, stretch.agents.peak) } : {}),
     at: new Date(stretch.to).toISOString(),
   };
@@ -580,7 +619,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
@@ -590,9 +629,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;
@@ -616,7 +656,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 } });
@@ -645,23 +685,22 @@ function historyEntries(floor = null, all = false) {
     const lines = parsedLines(file);
     if (!lines) continue;
     let cwd = null, steered = null;
-    const byDay = new Map();
+    const read = [];
     for (const line of lines) {
       if (typeof line.cwd === "string") cwd = line.cwd;
       if (typeof line.steered === "string") steered = line.steered;
       if (!line.timestamp || (line.type !== "user" && line.type !== "assistant")) continue;
       const at = Date.parse(line.timestamp);
       if (!Number.isFinite(at)) continue;
-      const day = new Date(at).toISOString().slice(0, 10);
-      if (!byDay.has(day)) byDay.set(day, []);
-      byDay.get(day).push(messageOf(line, at));
+      read.push(messageOf(line, at));
     }
+    read.sort((a, b) => a.at - b.at);
+    const byDay = byDayOf(read);
     const agents = agentsByDay(file, null);
     for (const [day, messages] of byDay) {
       if (messages.length === 0) continue;
-      messages.sort((a, b) => a.at - b.at);
       // Under-reporting is the safe side (THE FLOORS): a day that began before the account changed is not offered at all.
-      if (floor !== null && messages[0].at < floor) continue;
+      if (floor !== null && firstOf(messages) < floor) continue;
       const last = messages[messages.length - 1].at;
       // The live window belongs to the hook: a stretch that log_work may still report is not history.
       if (!all && Date.now() - last < WINDOW_HOURS * 3600_000) continue;
@@ -670,7 +709,7 @@ function historyEntries(floor = null, all = false) {
       if (CODEX_ROLLOUT.test(file)) entrySource.set(entry, "codex");
       if (ANTIGRAVITY_TRANSCRIPT.test(file)) entrySource.set(entry, "antigravity");
       if (DATABASE_SESSION.test(file)) entrySource.set(entry, file.slice(0, file.indexOf(":")));
-      entryFile.set(entry, { file, from: messages[0].at, folder: cwd ? String(cwd).split(/[\\/]/).filter(Boolean).pop() ?? null : null });
+      entryFile.set(entry, { file, from: firstOf(messages), folder: cwd ? String(cwd).split(/[\\/]/).filter(Boolean).pop() ?? null : null });
       entries.push(entry);
     }
   }
@@ -870,17 +909,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "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.mjs

@@ -168,7 +168,7 @@ async function apply(list, agreed = false) {
 }
 
 /** THE ALLOWLIST: what a line may carry, each value checked for its type. A key not named here never reaches the archive. */
-const COUNTS = ["seconds", "tokens_in", "tokens_out", "tokens_cache_read", "tokens_cache_write", "model_seconds", "tool_seconds", "human_seconds", "idle_seconds", "agent_runs", "agent_seconds", "agent_peak"];
+const COUNTS = ["seconds", "tokens_in", "tokens_out", "tokens_cache_read", "tokens_cache_write", "model_seconds", "tool_seconds", "human_seconds", "idle_seconds", "agent_runs", "agent_seconds", "agent_peak", "interrupts", "steers"];
 const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
 /** The hook's own words for a stretch (work area, kind, how it was steered, the measuring bases), kept as the hook sends them. */
 const WORDS = ["layer", "kind", "steered_from", "duration_basis", "token_basis", "turn_basis"];
@@ -195,6 +195,8 @@ function archiveLine(entry) {
   for (const key of WORDS) if (typeof entry[key] === "string" && WORD.test(entry[key])) line[key] = entry[key];
   if (Array.isArray(entry.layers) && entry.layers.length > 1 && entry.layers.every((word) => typeof word === "string" && WORD.test(word))) line.layers = entry.layers.slice(0, 8);
   if (typeof entry.exchanges === "number" && Number.isInteger(entry.exchanges) && entry.exchanges > 0) line.exchanges = entry.exchanges;
+  // The computer's offset from UTC when the stretch began (0.6.18), so a working day can be read in local time.
+  if (typeof entry.utc_offset === "string" && /^[+-]\d{2}:\d{2}$/.test(entry.utc_offset)) line.utc_offset = entry.utc_offset;
   // Commit hashes the stretch made, never a message: what ties AI time to delivered work in the repository.
   if (Array.isArray(entry.commits) && entry.commits.length > 0 && entry.commits.every((sha) => typeof sha === "string" && /^[0-9a-f]{7,40}$/.test(sha))) line.commits = entry.commits.slice(0, 50);
   // The project as a one-way hash of its name (owner/name, else the folder's own name): which days belong together, never which project.
@@ -244,6 +246,8 @@ function check(dir) {
   }
   const manifest = readJson(join(dir, "manifest.json")).value;
   if (rows.length > 0 && (!manifest || manifest.count !== lines.length || manifest.head !== lines.at(-1).hash)) return broken("manifest.json", "its count or head does not match the lines (lines were removed or added outside preserve)");
+  // THE MANIFEST'S SEAL (0.6.18, audit C9): a signed count and head, so a cut tail with a manifest edited to match is caught.
+  if (manifest && typeof manifest.signature === "string" && !signedBy(manifest)) return broken("manifest.json", "its signature does not verify with the key named in it (the count or the last line was changed)");
   const days = new Map();
   for (const line of lines) days.set(line.day, [...(days.get(line.day) ?? []), line]);
   const mine = deviceKey()?.publicX ?? null;
@@ -255,15 +259,19 @@ function check(dir) {
     if (!proof || proof.date !== day) return broken(where, "missing or unreadable");
     if (proof.count !== ofDay.length || proof.root !== rootOf(ofDay.map((line) => line.hash))) return broken(where, "the day's root does not match its lines");
     if (proof.signature === null) continue;
-    const { signature, ...body } = proof;
-    let valid = false;
-    try { valid = verify(null, Buffer.from(canonical(body)), createPublicKey({ key: { kty: "OKP", crv: "Ed25519", x: body.public_key }, format: "jwk" }), Buffer.from(signature, "base64url")); } catch { valid = false; }
-    if (!valid) return broken(where, "the signature does not verify with the key named in it");
+    if (!signedBy(proof)) return broken(where, "the signature does not verify with the key named in it");
     signed += 1;
-    if (body.public_key === mine) ours += 1;
+    if (proof.public_key === mine) ours += 1;
   }
-  return { lines, days, signed, ours, manifest };
+  return { lines, days, signed, ours, manifest, proofs: new Map([...days.keys()].map((day) => [day, readJson(join(dir, "proofs", `${day}.json`)).value])) };
 }
+/** Whether a signed body (a day's proof, the manifest) verifies under the key it names. */
+function signedBy(document) {
+  const { signature, ...body } = document;
+  try { return verify(null, Buffer.from(canonical(body)), createPublicKey({ key: { kty: "OKP", crv: "Ed25519", x: body.public_key }, format: "jwk" }), Buffer.from(signature, "base64url")); } catch { return false; }
+}
+/** Signed with this computer's key, or null: the body as it is signed. */
+const sealed = (body, key) => ({ ...body, signature: key ? sign(null, Buffer.from(canonical(body)), key.privateKey).toString("base64url") : null });
 
 function archive(dir) {
   IDS = computerIds();
@@ -297,13 +305,19 @@ function archive(dir) {
     prev = hashed.hash;
   }
   // A day that gained lines gets its root again over all of its lines; the lines themselves are never rewritten.
+  // THIS KEY SIGNS ONLY ITS OWN LINES (0.6.18, audit S7): a day is signed when every earlier line of it was already under
+  // this key's signature (or there were none); a day that came into the folder from elsewhere keeps an unsigned root.
   const key = deviceKey();
+  const ours = (document) => !document || (key && typeof document.signature === "string" && document.public_key === key.publicX);
   mkdirSync(join(dir, "proofs"), { recursive: true });
   for (const day of new Set(fresh.map((line) => line.day))) {
-    const body = proofBody(day, all.filter((line) => line.day === day), key);
-    writeFileSync(join(dir, "proofs", `${day}.json`), `${JSON.stringify({ ...body, signature: key ? sign(null, Buffer.from(canonical(body)), key.privateKey).toString("base64url") : null }, null, 1)}\n`);
+    const own = !existing.days?.has(day) || ours(existing.proofs?.get(day));
+    const body = proofBody(day, all.filter((line) => line.day === day), own ? key : null);
+    writeFileSync(join(dir, "proofs", `${day}.json`), `${JSON.stringify(sealed(body, own ? key : null), null, 1)}\n`);
   }
-  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`);
+  // The manifest is sealed the same way: a new archive, or one whose manifest this key already signed.
+  const manifestKey = !existing.manifest || ours(existing.manifest) ? key : null;
+  if (fresh.length > 0 || !existing.manifest) writeFileSync(join(dir, "manifest.json"), `${JSON.stringify(sealed({ 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, ...(manifestKey ? { public_key: manifestKey.publicX } : {}) }, manifestKey), 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 ${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.`);
@@ -314,8 +328,9 @@ function verifyArchive(dir) {
   const result = check(dir);
   if (result.broken) { say(`  BROKEN  ${result.broken}`); process.exit(1); }
   if (result.lines.length === 0) { say(`  Nothing to verify in ${dir}.`); return; }
-  const signedBy = result.signed === 0 ? "no day signed" : result.ours === result.signed ? `${result.signed} signed by this computer's key` : `${result.signed} signed (${result.ours} by this computer's key, ${result.signed - result.ours} by another key named in them)`;
-  say(`  OK  ${result.lines.length} stretches · ${result.days.size} days · the chain is whole · every day's root matches · ${signedBy}`);
+  const daySeal = result.signed === 0 ? "no day signed" : result.ours === result.signed ? `${result.signed} signed by this computer's key` : `${result.signed} signed (${result.ours} by this computer's key, ${result.signed - result.ours} by another key named in them)`;
+  const seal = typeof result.manifest?.signature !== "string" ? "manifest unsigned" : result.manifest.public_key === deviceKey()?.publicX ? "manifest signed by this computer's key" : "manifest signed by another key named in it";
+  say(`  OK  ${result.lines.length} stretches · ${result.days.size} days · the chain is whole · every day's root matches · ${daySeal} · ${seal}`);
 }
 
 /** --summary: what a person or a team reads from the archive, counted locally (preserve-summary.mjs) once the chain checks out. */

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.16";
+const CLI_VERSION = "0.6.18";
 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");
@@ -532,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.
@@ -542,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.");
@@ -631,24 +635,53 @@ 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("  Your AI apps hold no earlier sessions on this computer to send."); return; }
+  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 (each answer's tokens counted once, nothing lost at midnight, when each stretch began, how you steered");
+  say("  the agent, what the seconds were, 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"));
 }
 
 /**
@@ -843,6 +876,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");