worktrust 0.6.11 → 0.6.13

package/README.md

@@ -16,6 +16,12 @@ from WorkTrust's own site:
 curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
 ```
 
+**No account? Keep your history anyway.** Claude Code and Gemini CLI delete their sessions after 30
+days by default, and a deleted session can never be measured again. `npx worktrust@latest preserve` shows what
+each AI app on this computer keeps, keeps it longer on your yes, and writes a local, metadata-only
+record. It needs no account and opens no network connection: it stays on this computer until you
+yourself run a command that sends. See [Keep your history](#keep-your-history).
+
 ## What happens
 
 1. **A plan, then a question.** The command lists every AI app it found on this computer and the
@@ -36,7 +42,9 @@ curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
    this computer and asks `Send these as history? [y/N]`. Enter sends nothing. What goes is hours
    and tokens per day, never text, and WorkTrust shows it as earlier work, never as verified hours.
    Nothing from before the coupling is ever sent without that yes: the session hook starts at the
-   moment of coupling.
+   moment of coupling. Beside the seconds, each day says what they were (the model answering, tools
+   running, your own turns, pauses) and what the session's subagents did on their own clocks, as
+   counts; a subagent's hour is shown as an agent-hour and never as one of yours.
 5. **Codex only if you say yes.** With Codex on this computer it asks `Let Codex wake the session
    hook? [y/N]` and, on a yes, sets the one `notify` line in `~/.codex/config.toml` (the file is
    kept as `config.toml.worktrust-backup` first). Another program's `notify` is never replaced.
@@ -70,13 +78,107 @@ curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
    open, starts the session hook in the background, at most once an hour.
 
 ```
-npx worktrust history       send this computer's earlier sessions later (asks first)
+npx worktrust@latest history       send this computer's earlier sessions later (asks first)
 npx worktrust codex         let Codex wake the session hook (asks first)
 npx worktrust antigravity   let Antigravity wake the session hook (asks first)
-npx worktrust status        what is coupled here
-npx worktrust disconnect    take it out again (shows the plan, asks first)
+npx worktrust@latest status        what is coupled here
+npx worktrust@latest disconnect    take it out again (shows the plan, asks first)
+```
+
+## Keep your history
+
+**Why.** Your AI apps decide how long your history lives, and several delete it on their own schedule:
+
+| App | Kept by default | `preserve --apply` |
+|---|---|---|
+| Claude Code | 30 days, then deleted without notice | sets `cleanupPeriodDays` to 3650 |
+| Gemini CLI | 30 days | turns `general.sessionRetention` off |
+| Hermes Agent | 90 days after a session ended | prints the line to add (`sessions.auto_prune: false`) |
+| Codex CLI | no deletion documented | nothing to change |
+| Cursor, Copilot Chat, OpenCode, Goose, LM Studio | not documented | left alone |
+
+(From each vendor's own documentation, checked 6 October 2026. Copilot Chat also syncs its sessions
+to GitHub by default: `chat.sessionSync.enabled`.) A deleted session is a day of work that can never
+be shown again, by WorkTrust or by anyone.
+
+**Local, and yours.** `preserve` works on this computer only. It needs no WorkTrust account and no
+key, and it opens no network connection; `check-cli-package` refuses the package if `preserve.mjs` so
+much as imports a network module. What it keeps stays here **until you yourself run a command that
+sends**: `npx worktrust` to couple this computer, then `npx worktrust@latest history`, which shows what it
+would send and asks `[y/N]` first. Without those two, nothing ever leaves.
+
+```
+npx worktrust@latest preserve                  every step: the report, then asks to keep the settings and a local archive
+npx worktrust@latest preserve --apply          the settings step only: asks [y/N] per change, backs the file up first
+npx worktrust@latest preserve --archive [dir]  a local record of the measured days (default ~/AI-Evidence)
+npx worktrust@latest preserve --verify [dir]   check that record: was anything changed afterwards?
+npx worktrust@latest preserve --summary [dir]  hours, tokens per model, cache share and parallel sessions, from that record
 ```
 
+**Always the newest, from any terminal or agent.** Run it as `npx worktrust@latest …`: npx then asks npm for the
+newest version every time, where a bare `npx worktrust` may reuse a copy npm cached earlier. Which terminal or AI
+agent runs it makes no difference: `preserve` writes to your own user's places (the apps' settings files and
+`~/AI-Evidence`), so every terminal and agent on this computer under your user reaches the same archive, and lines
+from different versions sit side by side, each naming the version that measured it. Another user on the same computer
+gets an archive of their own. A coupled computer's session hook runs from its own copy in `~/.worktrust` and changes
+only with `npx worktrust@latest update`; the WorkTrust app says when a newer version is out.
+
+**One command walks it all.** `npx worktrust@latest preserve` shows the report, asks `Keep these settings? [y/N]`
+(then does what `--apply` does), asks `Keep a local archive in ~/AI-Evidence? [y/N]` (then does what `--archive`
+does; an archive already there is simply added to), and with an archive prints its check and its summary. Enter is
+No. Without a terminal, and without `--yes`, it changes nothing. The flags each do one step, for scripts.
+
+**Later, into WorkTrust, if you want.** Because `--apply` keeps the apps' own session files, coupling
+this computer months from now still finds them: `npx worktrust@latest history` measures them the same way the
+live hook does, and they arrive as history, labelled as such, never as work WorkTrust watched happen.
+The archive is a plain, documented format made for the same purpose; importing it directly is planned,
+not built.
+
+**What `--archive` keeps, per AI app per day.** The same measurement the session hook makes, and
+nothing it does not:
+
+| Field | What it is |
+|---|---|
+| `client` | the AI app (`claude`, `codex`, `cursor`, `copilot`, `hermes` …) |
+| `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 |
+| `agent_runs`, `agent_seconds`, `agent_peak` | subagents: how many ran, their own time, the most open at once (never added to `seconds`) |
+| `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 |
+| `commits` | the hashes of commits made in the stretch, never a message: what ties AI time to work in the repository |
+| `steered_from` | `remote` when the session ran over SSH |
+| `duration_basis`, `token_basis`, `turn_basis` | how the seconds, tokens and turns were measured |
+| `project` | a one-way hash of the project's name: which days belong together, never which project |
+| `stretch_ref` | a hash of the session's id and the day, so a stretch is archived once |
+| `device_id`, `profile_id` | which computer and which user profile on it, as one-way hashes (the machine's own id never appears) |
+| `collector_version` | the CLI version that measured it |
+| `seq`, `prev`, `hash` | the line's place, the hash of the line before it, and its own hash |
+
+A value the app did not record is left out, never written as 0. Each day also gets a proof in
+`proofs/<day>.json` (the day's line count, a root hash over its lines, and a signature with this
+computer's device key when it is coupled), and `manifest.json` holds the count and the last hash, so a
+removed line is caught. The manifest names the computer and profile too.
+
+**Never kept:** a prompt, an answer, code, a file or its path, a branch, a commit message, a title,
+terminal output, or anything typed. The text in your sessions is read only to find clocks, model names
+and counts, exactly as the session hook reads it.
+
+- **What `--apply` writes.** Only the settings in the table above, each on a typed `y`. The file is
+  copied to `settings.json.worktrust-backup-<date>` first, every other setting stays as it was, and a
+  value you set higher is never lowered. Hermes's YAML is never edited.
+- **Today is archived tomorrow.** A day goes into the archive once it is over; a later run only adds
+  lines and never rewrites one.
+- **What `--summary` counts.** From the archive, after its chain checks out: per month the measured
+  hours, the tokens per model and the share of input served from the cache (where tokens go, and so
+  where they can be saved), and the days on which two or more sessions ran in one project at the same
+  time, with the most open at once and their session time against the wall-clock time they covered.
+- **The archive is yours** to keep, copy, back up or delete. The free kit on
+  [worktrust.io/preserve](https://worktrust.io/preserve) is this package plus a guideline, for teams
+  that want the same record without WorkTrust.
+
 ## 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
@@ -108,9 +210,10 @@ which would delete every password on the computer, and many people rightly keep
 
 ## Why you can check it
 
-- **No dependencies and no install scripts.** Four plain files, about 2,600 lines in total, readable
+- **No dependencies and no install scripts.** Plain files, readable
   in an afternoon: `worktrust.mjs` (this command), `setup-mcp.mjs` (writes the MCP entries),
-  `log-session.mjs` (the session hook) and `count-behaviour.mjs` (the local counter).
+  `log-session.mjs` (the session hook), `count-behaviour.mjs` (the local counter) and `preserve.mjs`
+  (keep your history), with the readers they import.
 - **Nothing is downloaded at run time.** Everything that runs is in the package. The counter is
   pinned: it is not replaced from the network; a new one comes with a new version of this package.
 - **Provenance.** Every version is built and published from a public repository by GitHub Actions
@@ -123,7 +226,7 @@ which would delete every password on the computer, and many people rightly keep
 
 ## A computer that is already coupled, or shared
 
-- `npx worktrust connect` on a computer that is already coupled says to which account (masked) and
+- `npx worktrust@latest connect` on a computer that is already coupled says to which account (masked) and
   asks `Couple it again? [y/N]`. Enter and `--yes` mean No; `--replace` says yes in advance.
 - The browser page that approves it shows, large, which WorkTrust account is signed in, with
   **Use another account**: the computer goes to whoever approves it there.
@@ -132,13 +235,13 @@ which would delete every password on the computer, and many people rightly keep
 - When the new account is a different one, the old account sees a notice that its computer moved,
   with the computer's name and the moment, never the other account; no earlier work on this
   computer is offered to the new account, only work from the moment of coupling.
-- `npx worktrust status` shows the account this computer sends to.
+- `npx worktrust@latest status` shows the account this computer sends to.
 - Different people on one computer with their own OS user each couple their own: everything lives
   in that user's home folder, and the accounts never meet.
 
 ## Undo
 
-`npx worktrust disconnect` removes the WorkTrust entries (Hermes's hook with them), the hook (and Codex's `notify` line and
+`npx worktrust@latest disconnect` removes the WorkTrust entries (Hermes's hook with them), the hook (and Codex's `notify` line and
 Antigravity's `worktrust` hook when WorkTrust set them) and the key file, and empties
 `~/.worktrust` but for one small note of which account it fed (masked), so that a later coupling by
 another account offers none of this computer's earlier work.

package/log-session.mjs

@@ -107,7 +107,6 @@ async function refreshCounter(origin, announce) {
   } catch { return false; }
 }
 
-
 /** A pause longer than this is not work, so it is not counted. Five minutes. */
 const IDLE_CAP = 300;
 /**
@@ -129,6 +128,14 @@ const MIN_SECONDS = 60;
  * guessing where one piece of work ended and the next began.
  */
 const MAX_SECONDS = 28800;
+/** The door's ceilings for the layers (a day) and for a day's subagents: the same bounds its columns check. */
+const DAY_SECONDS = 86400;
+/** A tool gap is tool time up to thirty minutes (proposed, owner 2026-10-06); past that it is a wait, counted as idle. */
+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;
 
 /**
  * WHEN THE HOOK RUNS. SessionEnd alone was a bet that sessions end, and a session that stays open
@@ -269,7 +276,6 @@ function codexCoupling() {
   return null;
 }
 
-
 /** Which layer a set of paths touched — the same plain reading the connector uses for classes. */
 const LAYER_RULES = [
   ["database", /(^|\/)migrations?\/|\.sql$|(^|\/)(schema|seed)s?\.(prisma|sql|ts|rb)$/i],
@@ -332,7 +338,7 @@ function stretchesOf(file, since) {
     const at = Date.parse(line.timestamp);
     if (!Number.isFinite(at)) continue;
     if (since && at <= since) continue;
-    messages.push({ at, type: line.type, usage: line.message?.usage ?? null, model: line.message?.model ?? null, meta: line.isMeta === true, content: line.message?.content ?? null });
+    messages.push(messageOf(line, at));
   }
   if (messages.length === 0) return [];
   messages.sort((a, b) => a.at - b.at);
@@ -342,8 +348,76 @@ function stretchesOf(file, since) {
     if (!byDay.has(day)) byDay.set(day, []);
     byDay.get(day).push(message);
   }
-  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 }; }).filter(Boolean);
+  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);
+}
+
+/** 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,
+    // 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"),
+    // 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,
+  };
+};
+
+/**
+ * SUBAGENTS AS AGENT TIME, NEVER AS HOURS (owner, 2026-10-06). Claude Code writes each subagent's transcript beside its
+ * session (`<session>/subagents/*.jsonl`: 279 of them beside 48 sessions on the computer this was built on), and the
+ * sweep read only the sessions, so delegated work was invisible. Now each run is read for its clocks and sent as
+ * METADATA beside the parent's day: how many runs started that day, their own measured seconds (the same gap rule, the
+ * same cap), and how many were open at once at the busiest moment. None of it enters `seconds`: four agents working an
+ * hour are four agent-hours and one hour of the person's, and the record says which is which. Only Claude Code keeps
+ * subagents this way; every other client answers an empty map.
+ */
+function subagentFiles(file) {
+  if (!/\.jsonl$/.test(String(file)) || CODEX_ROLLOUT.test(file) || ANTIGRAVITY_TRANSCRIPT.test(file) || DATABASE_SESSION.test(file)) return [];
+  const dir = join(String(file).replace(/\.jsonl$/, ""), "subagents");
+  try { return readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => join(dir, name)); } catch { return []; }
+}
+function agentsByDay(file, since) {
+  const byDay = new Map();
+  for (const sub of subagentFiles(file)) {
+    const lines = parsedLines(sub);
+    if (!lines) continue;
+    const stamps = [];
+    let started = Infinity;
+    for (const line of lines) {
+      if (!line.timestamp || (line.type !== "user" && line.type !== "assistant")) continue;
+      const at = Date.parse(line.timestamp);
+      if (!Number.isFinite(at)) continue;
+      started = Math.min(started, at);
+      if (!(since && at <= since)) stamps.push(at);
+    }
+    // A RUN IS COUNTED ONCE, on the side of the watermark where it STARTED (review, 2026-10-06): a run that straddles the
+    // watermark was sent with the day it began and is not a second run on the next sweep; what it did after the
+    // watermark stays unsent, which is the safe direction.
+    if (stamps.length === 0 || (since && started <= since)) continue;
+    stamps.sort((a, b) => a - b);
+    // A run is counted on the day it started; its seconds go with it, the same rule as the parent's.
+    const day = new Date(stamps[0]).toISOString().slice(0, 10);
+    let seconds = 0;
+    for (let i = 1; i < stamps.length; i += 1) seconds += Math.min(IDLE_CAP, Math.round((stamps[i] - stamps[i - 1]) / 1000));
+    if (!byDay.has(day)) byDay.set(day, { runs: 0, seconds: 0, spans: [] });
+    const entry = byDay.get(day);
+    entry.runs += 1; entry.seconds += seconds; entry.spans.push([stamps[0], stamps[stamps.length - 1]]);
+  }
+  for (const entry of byDay.values()) entry.peak = peakOf(entry.spans);
+  return byDay;
 }
+/** The most spans open at one instant; a span that ends where another starts does not overlap it. */
+const peakOf = (spans) => {
+  const events = spans.flatMap(([from, to]) => [[from, 1], [to, -1]]).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  let open = 0, peak = 0;
+  for (const [, delta] of events) { open += delta; peak = Math.max(peak, open); }
+  return peak;
+};
 
 /**
  * IS THIS A HUMAN TURN? (2026-09-20)
@@ -387,7 +461,35 @@ 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, ...tokens, exchanges, model, from: messages[0].at, to: messages[messages.length - 1].at };
+  return { cwd, seconds: measured, layers: measured !== null ? timeLayers(messages) : null, ...tokens, exchanges, model, from: messages[0].at, to: messages[messages.length - 1].at };
+}
+
+/**
+ * HOW THE SECONDS WERE SPENT (owner, 2026-10-06: "observed time → AI active → agent-directed → verified work activity").
+ * `seconds` keeps its exact meaning above; this reads the same gaps a second time and says what each one WAS, by the
+ * message that ends it: the model's message (model time, capped as before), a tool's result or an agent run (tool time,
+ * NOT capped at five minutes, because a test suite that ran twenty minutes was twenty minutes of the agent's work; bounded
+ * by the stretch's own ceiling), or the person's next turn (human time, capped). What a cap cut off is idle, counted as
+ * idle and never as work. The four sum to the stretch's span, so nothing is hidden and nothing is double-counted.
+ */
+function timeLayers(messages) {
+  const split = { model: 0, tool: 0, human: 0, idle: 0 };
+  for (let i = 1; i < messages.length; i += 1) {
+    const gap = Math.max(0, Math.round((messages[i].at - messages[i - 1].at) / 1000));
+    const next = messages[i], prev = messages[i - 1];
+    // WAITS FOR THE PERSON ARE NOT TOOL TIME (review, 2026-10-06). A tool's result arrives when the tool is done, or when the
+    // person answered a question, approved a plan, or sat on a permission prompt. The first two are named by the tool and
+    // counted as human time; the third is invisible in the transcript, so a tool gap is counted as tool time only up to
+    // TOOL_CAP, and the rest as idle: a tool runs minutes, a person away from the keyboard does not.
+    const tool = (next.kind === "tool_result" || next.agentic || (prev.toolUse && next.kind === "assistant")) && !prev.waitsForPerson;
+    // ONE DEFINITION OF A HUMAN TURN (review, 2026-10-06): the same `isHumanTurn` that counts `exchanges`; a user line that
+    // is not one (a meta line the client injected, a textless line) is the loop's own and counts as model time.
+    const human = !tool && ((prev.waitsForPerson && next.kind === "tool_result") || (next.kind === "user" && !next.meta && isHumanTurn(next.content)));
+    const counted = Math.min(tool ? TOOL_CAP : IDLE_CAP, gap);
+    split[tool ? "tool" : human ? "human" : "model"] += counted;
+    split.idle += gap - counted;
+  }
+  return split;
 }
 
 /**
@@ -455,6 +557,10 @@ function payloadFor(stretch) {
     ...(repo ? { repo } : {}),
     ...(touched.shas.length > 0 ? { commits: touched.shas.slice(0, 50) } : {}),
     ...(stretch.ref ? { stretch_ref: stretch.ref } : {}), ...(stretch.steered ? { steered_from: stretch.steered } : {}),
+    // 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`.
+    ...(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(),
   };
 }
@@ -525,7 +631,7 @@ async function send(door, payload) {
  * matches commits by, and cutting on the calendar keeps `at` a real instant rather than an
  * average of one. Younger than the live window is left alone — that is `log_work`'s half.
  */
-function historyEntries(floor = null) {
+function historyEntries(floor = null, all = false) {
   const entries = [];
   for (const { file } of allTranscripts()) {
     const lines = parsedLines(file);
@@ -540,8 +646,9 @@ function historyEntries(floor = null) {
       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({ at, type: line.type, usage: line.message?.usage ?? null, model: line.message?.model ?? null, meta: line.isMeta === true, content: line.message?.content ?? null });
+      byDay.get(day).push(messageOf(line, at));
     }
+    const agents = agentsByDay(file, null);
     for (const [day, messages] of byDay) {
       if (messages.length === 0) continue;
       messages.sort((a, b) => a.at - b.at);
@@ -549,25 +656,13 @@ function historyEntries(floor = null) {
       if (floor !== null && messages[0].at < 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 (Date.now() - last < WINDOW_HOURS * 3600_000) continue;
-      let seconds = 0;
-      for (let i = 1; i < messages.length; i += 1) seconds += Math.min(IDLE_CAP, Math.round((messages[i].at - messages[i - 1].at) / 1000));
-      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.model) models.set(message.model, (models.get(message.model) ?? 0) + 1);
-      }
-      const { tokensIn, tokensOut, cacheRead, cacheWrite, shapeKnown } = tokensOf(messages);
-      const entry = payloadFor({
-        cwd, seconds: seconds >= MIN_SECONDS ? Math.min(MAX_SECONDS, seconds) : null,
-        tokensIn, tokensOut, cacheRead, cacheWrite, shapeKnown, exchanges, model: [...models.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null,
-        from: messages[0].at, to: last, ref: stretchRef(file, day), steered,
-      });
+      if (!all && Date.now() - last < WINDOW_HOURS * 3600_000) continue;
+      // The same measure as a live day (seconds, layers, tokens, turns, model); history differs only in the door it goes through.
+      const entry = payloadFor({ ...measure(cwd, messages), ref: stretchRef(file, day), steered, agents: agents.get(day) ?? null });
       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);
+      entryFile.set(entry, { file, from: messages[0].at, folder: cwd ? String(cwd).split(/[\\/]/).filter(Boolean).pop() ?? null : null });
       entries.push(entry);
     }
   }
@@ -756,7 +851,9 @@ const door = coupling();
 const codexDoor = codexCoupling();
 const doorFor = (entry) => (String(entry?.id ?? "").startsWith("codex:") ? codexDoor ?? door : door);
 const entrySource = new WeakMap(); // an entry → "codex" or "antigravity" by the client that wrote it; the sends route and name by it
-const entryFile = new WeakMap(); // a history entry → its transcript, so `--summary` can count sessions
+const entryFile = new WeakMap(); // a history entry → its transcript (`--summary` counts sessions), first moment and folder name (`--archive-lines`)
+// THE LOCAL ARCHIVE (`npx worktrust preserve --archive`, 2026-10-06): every measured day, live window and floors aside, as JSON lines to preserve.mjs on this computer, which keeps metadata only; nothing is sent.
+if (flag("archive-lines")) { for (const entry of historyEntries(null, true)) console.log(JSON.stringify({ ...entry, client: entrySource.get(entry) ?? "claude", started_at: new Date(entryFile.get(entry).from).toISOString(), folder: entryFile.get(entry).folder })); process.exit(0); }
 if (!door && !codexDoor && !DRY) { process.exit(0); } // Not coupled on this machine: nothing to do, quietly.
 
 if (flag("history")) {
@@ -765,7 +862,7 @@ if (flag("history")) {
   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))).size, hours: Math.round(hours * 10) / 10, first: months[0] ?? null, last: months.at(-1) ?? null })); process.exit(0); }
+  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 })); process.exit(0); }
   console.log(`${entries.length} day-stretches · ${hours.toFixed(1)} measured hours · ${months.join(", ")}`);
   if (DRY) {
     // One example in full: the shape is the argument for trusting it, and a summary hides it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "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": {
@@ -14,6 +14,8 @@
     "transcript-readers.mjs",
     "session-databases.mjs",
     "config-edits.mjs",
+    "preserve.mjs",
+    "preserve-summary.mjs",
     "README.md",
     "SECURITY.md",
     "LICENSE"

package/preserve-summary.mjs

@@ -0,0 +1,39 @@
+/**
+ * --summary: what a person or a team reads from the archive, counted locally after the chain checks out. Per month the
+ * hours, the tokens per model and the share of input served from the cache (where the tokens go, and so where they
+ * can be saved); and the PARALLEL WORK: per project and day the sessions' summed time against the wall-clock time they
+ * covered together, and the most open at once. A stretch without a project or a measured token stays out of that
+ * figure; nothing is estimated.
+ *
+ * Pure: the archive's verified lines in, the lines to print out. No file, no clock, no network.
+ */
+export function summaryLines(lines) {
+  const out = [];
+  const months = new Map();
+  const month = (key) => months.get(key) ?? months.set(key, { seconds: 0, models: new Map(), input: 0, cached: 0, days: new Map() }).get(key);
+  for (const line of lines) {
+    const m = month(line.day.slice(0, 7));
+    m.seconds += line.seconds ?? 0;
+    if (typeof line.tokens_in === "number" || typeof line.tokens_out === "number") {
+      const name = line.model ?? "model not recorded";
+      m.models.set(name, (m.models.get(name) ?? 0) + (line.tokens_in ?? 0) + (line.tokens_out ?? 0));
+    }
+    if (typeof line.tokens_in === "number" && typeof line.tokens_cache_read === "number") { m.input += line.tokens_in + line.tokens_cache_read; m.cached += line.tokens_cache_read; }
+    if (line.project) { const key = `${line.day}|${line.project}`; (m.days.get(key) ?? m.days.set(key, []).get(key)).push([Date.parse(line.started_at), Date.parse(line.ended_at), line.seconds ?? 0]); }
+  }
+  const hours = (seconds) => (seconds / 3600).toFixed(1);
+  for (const [key, m] of [...months].sort()) {
+    out.push(`  ${key}  ${hours(m.seconds)} h measured`);
+    for (const [model, tokens] of [...m.models].sort((a, b) => b[1] - a[1])) out.push(`    ${model.padEnd(28)} ${tokens.toLocaleString("en")} tokens`);
+    if (m.input > 0) out.push(`    cache share of input        ${Math.round((m.cached / m.input) * 100)}%`);
+    let parallelDays = 0, peak = 1, summed = 0, wall = 0;
+    for (const spans of m.days.values()) {
+      const edges = spans.flatMap(([from, to]) => [[from, 1], [to, -1]]).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+      let open = 0, top = 0, covered = 0, since = 0;
+      for (const [at, step] of edges) { if (open > 0) covered += at - since; open += step; since = at; top = Math.max(top, open); }
+      if (top > 1) { parallelDays += 1; peak = Math.max(peak, top); summed += spans.reduce((sum, span) => sum + span[2], 0); wall += covered / 1000; }
+    }
+    if (parallelDays > 0) out.push(`    parallel sessions in one project on ${parallelDays} day${parallelDays === 1 ? "" : "s"}: up to ${peak} at once, ${hours(summed)} h of session time in ${hours(wall)} h of wall-clock time`);
+  }
+  return out;
+}

package/preserve.mjs

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+/**
+ * KEEP YOUR HISTORY: `npx worktrust@latest preserve` (2026-10-06). Local only: no account, no network, no key needed.
+ * The bare command walks every step on its own yes (see `guided` below); the flags do one step each, for scripts:
+ * --apply [--yes] keep the settings · --archive [dir] the metadata-only archive (default ~/AI-Evidence) · --verify [dir]
+ * its hashes, chain, roots and signatures · --summary [dir] hours, tokens per model, cache share, parallel sessions.
+ *
+ * WHY. The session hook measures from the AI apps' own session files, and several apps delete them: Claude Code after
+ * 30 days (`cleanupPeriodDays`, minimum 1, 0 is invalid), Gemini CLI after 30 (`general.sessionRetention`), Hermes Agent
+ * 90 days after a session ended (`sessions.auto_prune`). A deleted file is a day never measured again. Codex documents
+ * no deletion; Cursor, Copilot Chat, OpenCode, Goose and LM Studio document none, so nothing is claimed or changed for
+ * them (their docs, 2026-10-06).
+ *
+ * WHAT CHANGES, only on a typed y (Enter is No; --yes agrees in advance; no terminal and no --yes changes nothing):
+ * Claude Code's `cleanupPeriodDays` to 3650 when unset or lower, and Gemini CLI's `sessionRetention.enabled` to false;
+ * the file is copied beside itself first, every other key kept, a higher value never lowered, a file that is not plain
+ * JSON left alone. Hermes's YAML is never edited: the line is printed.
+ *
+ * WHAT THE ARCHIVE HOLDS. The hook's own day-stretches (`log-session.mjs --archive-lines`; nothing is parsed here) as
+ * allowlisted JSON lines in <dir>/YYYY/MM/stretches.jsonl: clocks, seconds and their layers, tokens, subagents, the
+ * model, the hook's own words, a hash of the project, the computer and profile as hashes. Never a prompt, an answer,
+ * code, a path, a branch or a title; a measurement not made is absent, never 0. Each line chains to the one before
+ * (`prev`, `hash`), appended and never rewritten; each day has proofs/<day>.json, its root, signed with the device key
+ * (~/.worktrust/key.json) when there is one. Today waits for the next run. Nothing leaves this computer.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import { createHash, createPrivateKey, createPublicKey, sign, verify } from "node:crypto";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join, relative } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { summaryLines } from "./preserve-summary.mjs";
+
+const args = process.argv.slice(2).filter((arg) => arg !== "preserve");
+const has = (name) => args.includes(`--${name}`);
+/** `--archive [dir]`: the folder named after the flag, or the default. */
+const folderAfter = (name) => { const at = args.indexOf(`--${name}`); const next = args[at + 1]; return next && !next.startsWith("--") ? next.replace(/^~(?=\/|$)/, homedir()) : join(homedir(), "AI-Evidence"); };
+const HERE = dirname(fileURLToPath(import.meta.url));
+const home = (...parts) => join(homedir(), ...parts);
+const say = (line = "") => process.stdout.write(`${line}\n`);
+const today = () => new Date().toISOString().slice(0, 10);
+/** Which collector wrote a line: the CLI's version when worktrust.mjs starts this, else the package's beside it. */
+const COLLECTOR = process.env.WORKTRUST_COLLECTOR || (() => { try { return `worktrust-cli/${JSON.parse(readFileSync(join(HERE, "package.json"), "utf8")).version}`; } catch { return "worktrust-cli/source"; } })();
+const KEEP_DAYS = 3650;
+let IDS = {}; // filled once per archive run (computerIds), never read at import
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+/** Keys sorted at every level: the same object always hashes the same, whatever order it was written in. */
+const canonical = (value) => (Array.isArray(value) ? `[${value.map(canonical).join(",")}]` : value && typeof value === "object" ? `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}` : JSON.stringify(value));
+const isDir = (path) => { try { return statSync(path).isDirectory(); } catch { return false; } };
+/** A settings file: { value } when it is a JSON object or absent ({}), { value: null } when it exists and is not one. */
+function readJson(file) {
+  if (!existsSync(file)) return { exists: false, value: {} };
+  try { const value = JSON.parse(readFileSync(file, "utf8")); return { exists: true, value: value && typeof value === "object" && !Array.isArray(value) ? value : null }; } catch { return { exists: true, value: null }; }
+}
+const appData = (app) => (platform() === "win32" && process.env.APPDATA ? join(process.env.APPDATA, app) : platform() === "darwin" ? home("Library", "Application Support", app) : join(process.env.XDG_CONFIG_HOME || home(".config"), app));
+
+/** CLAUDE CODE: ~/.claude/projects/<project>/<session>.jsonl, deleted after `cleanupPeriodDays` (default 30). */
+function claudeCode() {
+  const file = home(".claude", "settings.json");
+  const { value } = readJson(file);
+  const set = typeof value?.cleanupPeriodDays === "number" ? value.cleanupPeriodDays : null;
+  const days = set ?? 30;
+  return {
+    name: "Claude Code", found: isDir(home(".claude")), file,
+    keeps: value === null ? `${file} is not plain JSON; the default is 30 days` : set === null ? "30 days (the default; cleanupPeriodDays is not set)" : `${set} days (cleanupPeriodDays)`,
+    risk: days >= KEEP_DAYS ? "none: transcripts are kept ten years or more" : `transcripts not written for ${days} days are deleted in the background, and the hours in them with them`,
+    change: value === null ? { manual: [`add "cleanupPeriodDays": ${KEEP_DAYS} to ${file}`] } : days < KEEP_DAYS ? { says: `cleanupPeriodDays ${set ?? "unset"} → ${KEEP_DAYS} in ${file}`, next: (settings) => ({ ...settings, cleanupPeriodDays: KEEP_DAYS }) } : null,
+  };
+}
+/** GEMINI CLI: ~/.gemini/tmp/<project_hash>/chats, cleaned by `general.sessionRetention` (on by default, maxAge "30d"). */
+function geminiCli() {
+  const file = home(".gemini", "settings.json");
+  const { exists, value } = readJson(file);
+  const retention = value?.general?.sessionRetention;
+  const on = retention?.enabled !== false;
+  const age = typeof retention?.maxAge === "string" ? retention.maxAge : "30d";
+  return {
+    name: "Gemini CLI", found: isDir(home(".gemini", "tmp")) || exists, file,
+    keeps: value === null ? `${file} is not plain JSON (comments?); the default is 30d` : !on ? "kept (general.sessionRetention.enabled: false)" : `${age}${retention?.maxAge ? " (general.sessionRetention.maxAge)" : " (the default; general.sessionRetention is not set)"}`,
+    risk: on ? `chats older than ${age} are deleted when Gemini CLI starts` : "none: the cleanup is off",
+    change: value === null ? { manual: [`set "general": { "sessionRetention": { "enabled": false } } in ${file}`] } : on ? { says: `general.sessionRetention.enabled → false in ${file}`, next: (settings) => ({ ...settings, general: { ...(settings.general ?? {}), sessionRetention: { ...(settings.general?.sessionRetention ?? {}), enabled: false } } }) } : null,
+  };
+}
+/** HERMES AGENT: ~/.hermes/state.db, pruned by `sessions.auto_prune` (default true) after `sessions.retention_days` (90). */
+function hermesAgent() {
+  const base = platform() === "win32" && process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "hermes") : home(".hermes");
+  const file = join(base, "config.yaml");
+  let rows = [];
+  try { rows = readFileSync(file, "utf8").split("\n"); } catch { /* none */ }
+  // Read only, never written: the `sessions:` block at the top level and its two keys, plainly written.
+  const start = rows.findIndex((row) => /^sessions:\s*(#.*)?$/.test(row));
+  const block = start < 0 ? [] : rows.slice(start + 1, (() => { const end = rows.findIndex((row, at) => at > start && /^\S/.test(row)); return end < 0 ? rows.length : end; })());
+  const read = (key) => block.map((row) => new RegExp(`^\\s+${key}:\\s*([^#\\s]+)`).exec(row)?.[1]).find(Boolean);
+  const prune = read("auto_prune") !== "false";
+  const days = Number(read("retention_days") ?? 90);
+  return {
+    name: "Hermes Agent", found: isDir(base), file,
+    keeps: prune ? `${days} days after a session ended${read("auto_prune") || read("retention_days") ? " (sessions in config.yaml)" : " (the default: sessions.auto_prune is on)"}` : "kept (sessions.auto_prune: false)",
+    risk: prune ? `ended sessions are pruned from state.db after ${days} days` : "none: pruning is off",
+    change: prune ? { manual: start < 0 ? [`add to ${file}:`, "  sessions:", "    auto_prune: false"] : [`in ${file}, under sessions:, set`, "    auto_prune: false"] } : null,
+  };
+}
+const codexCli = () => ({ name: "Codex", found: isDir(home(".codex")), keeps: "no deletion documented (older rollouts are compressed)", risk: "none documented", change: null });
+/** Retention not documented: said plainly, nothing changed. */
+const undocumented = (name, places, note) => ({ name, found: places.some(isDir), keeps: "not documented", risk: note ?? "unknown: the app documents no retention", change: null });
+const clients = () => [
+  claudeCode(), geminiCli(), hermesAgent(), codexCli(),
+  undocumented("Cursor", [appData("Cursor"), home(".cursor")]),
+  undocumented("Copilot Chat", ["Code", "Code - Insiders"].map((app) => join(appData(app), "User", "globalStorage", "github.copilot-chat")), "unknown: no retention documented; VS Code also syncs chat sessions to GitHub by default (chat.sessionSync.enabled)"),
+  undocumented("OpenCode", [join(process.env.XDG_DATA_HOME || home(".local", "share"), "opencode")]),
+  undocumented("Goose", [home(".local", "share", "goose"), home("Library", "Application Support", "Block", "goose"), home(".config", "goose")]),
+  undocumented("LM Studio", [home(".lmstudio"), home(".cache", "lm-studio")]),
+];
+
+function report(list) {
+  say();
+  say("  WorkTrust · preserve: how long each AI app on this computer keeps its sessions");
+  say("  Nothing is sent anywhere, and nothing changes without your yes.");
+  for (const client of list) {
+    say();
+    if (!client.found) { say(`  ${client.name.padEnd(14)} not on this computer`); continue; }
+    say(`  ${client.name.padEnd(14)} found`);
+    say(`    keeps    ${client.keeps}`);
+    say(`    risk     ${client.risk}`);
+    if (client.change?.says) say(`    --apply  ${client.change.says}`);
+    else if (client.change?.manual) { say(`    by hand  ${client.change.manual[0]}`); for (const row of client.change.manual.slice(1)) say(`             ${row}`); }
+    else say("    --apply  nothing to change");
+  }
+  say();
+}
+
+async function ask(question) {
+  if (has("yes")) return true;
+  if (!process.stdin.isTTY) return null;
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = (await prompt.question(`  ${question} [y/N] `)).trim().toLowerCase();
+  prompt.close();
+  return answer === "y" || answer === "yes";
+}
+
+/** A dated copy beside the file, never over an earlier one; then the new JSON, every other key as it was. */
+function writeWithBackup(file, next) {
+  let backup = null;
+  if (existsSync(file)) {
+    backup = `${file}.worktrust-backup-${today()}`;
+    for (let n = 2; existsSync(backup); n += 1) backup = `${file}.worktrust-backup-${today()}-${n}`;
+    copyFileSync(file, backup);
+  }
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`);
+  return backup;
+}
+
+async function apply(list, agreed = false) {
+  for (const client of list.filter((entry) => entry.found && entry.change)) {
+    if (client.change.manual) { say(`  ${client.name}: not edited here; ${client.change.manual[0]}`); for (const row of client.change.manual.slice(1)) say(`    ${row}`); continue; }
+    const yes = agreed || await ask(`${client.name}: ${client.change.says}?`);
+    if (yes === null) { say(`  ${client.name}: not a terminal, nothing changed. Add --yes to agree in advance.`); continue; }
+    if (!yes) { say(`  ${client.name}: left as it is.`); continue; }
+    const { value } = readJson(client.file);
+    if (value === null) { say(`  ${client.name}: ${client.file} is no longer plain JSON; left as it is.`); continue; }
+    const backup = writeWithBackup(client.file, client.change.next(value));
+    say(`  ✓ ${client.name}: ${client.change.says}${backup ? ` (the earlier file is kept as ${backup})` : ""}`);
+  }
+  say();
+  say("  Restart the apps whose settings changed. Nothing was sent anywhere.");
+}
+
+/** 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 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"];
+const WORD = /^[a-z][A-Za-z]{1,31}$/;
+/** WHICH COMPUTER, WHICH PROFILE: the one-way hashes `worktrust connect` derives (worktrust.mjs `computerIds`), the same text, so they match. */
+function computerIds() {
+  let machine = null;
+  try {
+    const os = platform();
+    if (os === "darwin") machine = execFileSync("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], { encoding: "utf8", timeout: 3000 }).match(/"IOPlatformUUID" = "([0-9A-Fa-f-]{36})"/)?.[1] ?? null;
+    else if (os === "win32") machine = execFileSync("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"], { encoding: "utf8", timeout: 3000 }).match(/MachineGuid\s+REG_SZ\s+([0-9A-Fa-f-]{36})/)?.[1] ?? null;
+    else for (const file of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) if (!machine && existsSync(file)) { const id = readFileSync(file, "utf8").trim(); if (/^[0-9a-f]{32}$/.test(id)) machine = id; }
+  } catch { /* unreadable: no identity */ }
+  if (process.env.WORKTRUST_MACHINE_ID) machine = process.env.WORKTRUST_MACHINE_ID; // tests only
+  if (!machine) return {};
+  const hash = (text) => createHash("sha256").update(text).digest("base64url");
+  return { device_id: hash(`worktrust-machine|${machine.toLowerCase()}`), profile_id: hash(`worktrust-profile|${machine.toLowerCase()}|${homedir()}`) };
+}
+function archiveLine(entry) {
+  if (typeof entry?.client !== "string" || !/^[a-z][a-z0-9-]{0,31}$/.test(entry.client) || !ISO.test(entry.started_at ?? "") || !ISO.test(entry.at ?? "") || !/^[A-Za-z0-9_-]{16,128}$/.test(entry.stretch_ref ?? "")) return null;
+  const line = { client: entry.client, day: entry.started_at.slice(0, 10), started_at: entry.started_at, ended_at: entry.at };
+  for (const key of COUNTS) if (typeof entry[key] === "number" && Number.isFinite(entry[key]) && entry[key] >= 0) line[key] = entry[key];
+  if (typeof entry.model === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/ -]{0,63}$/.test(entry.model)) line.model = entry.model;
+  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;
+  // 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.
+  const name = entry.repo ?? entry.folder;
+  if (typeof name === "string" && name) line.project = sha256(`worktrust-project|${name}`);
+  return { ...line, stretch_ref: entry.stretch_ref, ...IDS, collector_version: COLLECTOR };
+}
+
+/** The device key, when this computer is coupled: its private half signs, its public half goes into the proof. */
+function deviceKey() {
+  try {
+    const key = JSON.parse(Buffer.from(readFileSync(home(".worktrust", "key.json"), "utf8"), "base64").toString("utf8"));
+    const privateKey = createPrivateKey(key.device);
+    return { privateKey, publicX: createPublicKey(privateKey).export({ format: "jwk" }).x };
+  } catch { return null; }
+}
+
+/** Every line of an archive, where it lives, parsed or not. */
+function readArchive(dir) {
+  const rows = [];
+  for (const year of readdirSafe(dir).filter((name) => /^\d{4}$/.test(name)).sort()) for (const month of readdirSafe(join(dir, year)).filter((name) => /^\d{2}$/.test(name)).sort()) {
+    const file = join(dir, year, month, "stretches.jsonl");
+    if (!existsSync(file)) continue;
+    readFileSync(file, "utf8").split("\n").forEach((text, at) => { if (text.trim()) { let line = null; try { line = JSON.parse(text); } catch { /* reported by check */ } rows.push({ line, where: `${year}/${month}/stretches.jsonl line ${at + 1}`, month: `${year}-${month}` }); } });
+  }
+  return rows;
+}
+function readdirSafe(dir) { try { return readdirSync(dir); } catch { return []; } }
+const rootOf = (hashes) => sha256(hashes.join("\n"));
+const proofBody = (date, lines, key) => ({ date, count: lines.length, root: rootOf(lines.map((line) => line.hash)), collector_version: COLLECTOR, ...(key ? { public_key: key.publicX } : {}) });
+
+/** THE CHECK, shared by --verify and by --archive before it appends: the first break, or the archive's facts. */
+function check(dir) {
+  const rows = readArchive(dir);
+  const broken = (where, why) => ({ broken: `${where}: ${why}` });
+  for (const { line, where, month } of rows) {
+    if (!line || typeof line !== "object") return broken(where, "not a JSON line");
+    const { hash, ...rest } = line;
+    if (hash !== sha256(canonical(rest))) return broken(where, "its hash does not match its content");
+    if (line.day?.slice(0, 7) !== month) return broken(where, `a line of ${line.day} in the month folder ${month}`);
+  }
+  const lines = rows.map((row) => row.line).sort((a, b) => a.seq - b.seq);
+  for (const [at, line] of lines.entries()) {
+    const where = rows.find((row) => row.line === line).where;
+    if (line.seq !== at + 1) return broken(where, `seq ${line.seq} where ${at + 1} was expected (a line is missing or doubled)`);
+    if (line.prev !== (at === 0 ? null : lines[at - 1].hash)) return broken(where, "prev does not name the line before it: the chain is broken");
+  }
+  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)");
+  const days = new Map();
+  for (const line of lines) days.set(line.day, [...(days.get(line.day) ?? []), line]);
+  const mine = deviceKey()?.publicX ?? null;
+  let signed = 0, ours = 0;
+  for (const name of readdirSafe(join(dir, "proofs"))) if (!days.has(name.replace(/\.json$/, ""))) return broken(`proofs/${name}`, "a proof for a day with no lines");
+  for (const [day, ofDay] of days) {
+    const where = `proofs/${day}.json`;
+    const proof = readJson(join(dir, "proofs", `${day}.json`)).value;
+    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");
+    signed += 1;
+    if (body.public_key === mine) ours += 1;
+  }
+  return { lines, days, signed, ours, manifest };
+}
+
+function archive(dir) {
+  IDS = computerIds();
+  const existing = existsSync(join(dir, "manifest.json")) || readArchive(dir).length > 0 ? check(dir) : { lines: [], manifest: null };
+  if (existing.broken) { say(`  The archive in ${dir} does not verify, so nothing was added: ${existing.broken}`); process.exit(1); }
+  const hook = spawnSync(process.execPath, [join(HERE, "log-session.mjs"), "--archive-lines"], { encoding: "utf8", maxBuffer: 1 << 29, env: { ...process.env, WORKTRUST_MCP_URL: "", WORKTRUST_MCP_TOKEN: "", WORKTRUST_HOOK_INPUT: "" } });
+  if (hook.status !== 0) { say(`  The session hook could not read this computer's sessions: ${(hook.stderr || "").trim().split("\n").pop()}`); process.exit(1); }
+  const known = new Set(existing.lines.map((line) => line.stretch_ref));
+  const fresh = [];
+  let waiting = 0;
+  for (const text of hook.stdout.split("\n")) {
+    let entry; try { entry = JSON.parse(text); } catch { continue; }
+    const line = archiveLine(entry);
+    if (!line || known.has(line.stretch_ref)) continue;
+    if (line.day >= today()) { waiting += 1; continue; }
+    known.add(line.stretch_ref);
+    fresh.push(line);
+  }
+  fresh.sort((a, b) => a.started_at.localeCompare(b.started_at) || a.client.localeCompare(b.client) || a.stretch_ref.localeCompare(b.stretch_ref));
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  let prev = existing.lines.at(-1)?.hash ?? null, seq = existing.lines.length;
+  const all = [...existing.lines];
+  for (const line of fresh) {
+    const chained = { ...line, seq: (seq += 1), prev };
+    const hashed = { ...chained, hash: sha256(canonical(chained)) };
+    mkdirSync(join(dir, line.day.slice(0, 4), line.day.slice(5, 7)), { recursive: true });
+    appendFileSync(join(dir, line.day.slice(0, 4), line.day.slice(5, 7), "stretches.jsonl"), `${JSON.stringify(hashed)}\n`);
+    all.push(hashed);
+    prev = hashed.hash;
+  }
+  // A day that gained lines gets its root again over all of its lines; the lines themselves are never rewritten.
+  const key = deviceKey();
+  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`);
+  }
+  if (fresh.length > 0 || !existing.manifest) writeFileSync(join(dir, "manifest.json"), `${JSON.stringify({ format: "worktrust-ai-evidence/1", collector_version: COLLECTOR, created: existing.manifest?.created ?? new Date().toISOString(), updated: new Date().toISOString(), clients: [...new Set(all.map((line) => line.client))].sort(), ...IDS, count: all.length, head: prev }, null, 1)}\n`);
+  say();
+  say(`  ✓ ${fresh.length} new day-stretch${fresh.length === 1 ? "" : "es"} archived in ${dir} (${all.length} in all)${key ? ", each day's root signed with this computer's device key" : ", unsigned (no device key on this computer)"}.`);
+  if (waiting > 0) say(`    ${waiting} of today wait for tomorrow's run: a day is archived once it is over.`);
+  say("    Metadata only: clocks, counts, model names, a hash of each project's name. Nothing was sent.");
+}
+
+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}`);
+}
+
+/** --summary: what a person or a team reads from the archive, counted locally (preserve-summary.mjs) once the chain checks out. */
+function summary(dir) {
+  const result = check(dir);
+  if (result.broken) { say(`  BROKEN  ${result.broken}`); process.exit(1); }
+  for (const line of summaryLines(result.lines)) say(line);
+  if (result.lines.length === 0) say(`  Nothing archived in ${dir} yet. Run: npx worktrust@latest preserve --archive`);
+}
+
+/** THE ONE COMMAND (owner, 2026-10-07: typed from a video): the report; the settings on a yes (--apply); an archive on a yes
+ *  (--archive; one already there is added to); then its check and summary. Enter is No; no terminal changes nothing. */
+async function guided() {
+  const list = clients(), dir = join(homedir(), "AI-Evidence");
+  report(list);
+  if (list.some((client) => client.found && client.change?.says)) {
+    const keep = await ask("Keep these settings?");
+    if (keep) await apply(list, true);
+    else say(keep === null ? "  Not a terminal: no setting changed. Add --yes to agree in advance." : "  Settings left as they are.");
+  }
+  const kept = existsSync(join(dir, "manifest.json"));
+  const write = kept ? (has("yes") || process.stdin.isTTY ? true : null) : await ask(`Keep a local archive in ${dir}?`);
+  if (write) archive(dir);
+  else if (!kept) say(write === null ? "  Not a terminal: no archive written. Add --yes to agree in advance." : "  No archive written.");
+  if (existsSync(join(dir, "manifest.json"))) { say(); verifyArchive(dir); summary(dir); }
+}
+
+if (has("summary")) summary(folderAfter("summary"));
+else if (has("verify")) verifyArchive(folderAfter("verify"));
+else if (has("archive")) archive(folderAfter("archive"));
+else if (has("apply")) { const list = clients(); report(list); await apply(list); }
+else await guided();

package/session-databases.mjs

@@ -371,7 +371,7 @@ export function cursorLines(pseudo) {
  * model finished (`modelState.completedAt`), the model it resolved to and the prompt and output tokens. The messages,
  * the responses and the tool calls' text are parsed with the file and never kept. Agent mode runs a request's tools
  * between those two clocks without stamping each step, so under the same rule as every other client that span counts
- * up to the idle cap, as one gap.
+ * up to the idle cap, as one gap, in `seconds`; in the layers it is the agent's run, whole (the assistant line says `agentic`).
  */
 export function copilotHomes(given) { return given ? [given.replace(/^~(?=\/|$)/, homedir())] : [...userDirs("Code"), ...userDirs("Code - Insiders")]; }
 export function* copilotSessions(homes) {
@@ -420,7 +420,8 @@ export function copilotLines(pseudo) {
     if (!done || done < asked) continue;
     const meta = request?.result?.metadata ?? {};
     const usage = Number(meta.promptTokens) || Number(meta.outputTokens) ? { usage: { input_tokens: Number(meta.promptTokens) || 0, output_tokens: Number(meta.outputTokens) || 0 } } : {};
-    lines.push({ type: "assistant", timestamp: new Date(done).toISOString(), message: { model: cleanModel(String(meta.resolvedModel ?? request?.modelId ?? "").replace(/^copilot\//, "")), ...usage, content: [] } });
+    // `agentic` (owner, 2026-10-06): the request's own run, asked → completed, is the agent's time; the hook files that gap as tool time, uncapped.
+    lines.push({ type: "assistant", timestamp: new Date(done).toISOString(), agentic: true, message: { model: cleanModel(String(meta.resolvedModel ?? request?.modelId ?? "").replace(/^copilot\//, "")), ...usage, content: [] } });
   }
   return lines;
 }

package/worktrust.mjs

@@ -7,11 +7,15 @@
  *   npx worktrust --dry-run             show the plan only; nothing is written, nothing is sent
  *   npx worktrust --yes                 no question (for scripts); the computer is still approved in the app
  *   npx worktrust --device              a computer without a browser (SSH): type a code on another device
- *   npx worktrust connect               couple again, also on a computer already coupled
- *   npx worktrust update                this computer onto the newest CLI, same key, no new pairing
- *   npx worktrust history               send this computer's earlier sessions as history (asks first)
- *   npx worktrust disconnect            show what comes out, ask, take it out again
- *   npx worktrust status                what is coupled here
+ *   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 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,
+ *                                       --archive [dir] a local metadata-only record, --verify [dir] checks it,
+ *                                       --summary [dir] counts hours, tokens and parallel sessions from it);
+ *                                       local only: no account, no key, no network (preserve.mjs)
  *
  * WHAT RUNS. From the npm package, everything that runs is in the package: this file,
  * `setup-mcp.mjs` (gives every AI app here the WorkTrust door), `log-session.mjs` (the session hook)
@@ -65,7 +69,7 @@ const command = args.find((arg, at) => !arg.startsWith("--") && !(at > 0 && VALU
 const flag = (name) => { const at = args.indexOf(`--${name}`); return at >= 0 ? args[at + 1] : undefined; };
 const has = (name) => args.includes(`--${name}`);
 /** This CLI's version, said to the door so the app can tell which computer runs an old one (check-cli-package holds it equal to package.json). */
-const CLI_VERSION = "0.6.11";
+const CLI_VERSION = "0.6.13";
 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");
@@ -208,7 +212,7 @@ async function pairByBrowser(host, extra) {
   const exchange = await post("/api/cli/token", { device_code: secret, code, code_verifier: verifier }).catch(() => null);
   if (!exchange || exchange.status !== 200 || !exchange.json.token) fail(`the approval could not be exchanged (${exchange?.json?.error ?? "no answer"}). Run \`worktrust connect\` again.`);
   say(`  ✓ Approved as "${exchange.json.label}"${exchange.json.account ? ` for the WorkTrust account ${exchange.json.account}` : ""}`);
-  if (exchange.json.account) say("    Not your account? Run `npx worktrust disconnect` now and revoke it in WorkTrust.");
+  if (exchange.json.account) say("    Not your account? Run `npx worktrust@latest disconnect` now and revoke it in WorkTrust.");
   if (extraBound && exchange.json.bound === false) say("  ! WorkTrust did not bind the key to this computer; it works like a key made by hand.");
   return paired(exchange.json);
 }
@@ -237,7 +241,7 @@ async function pairByCode(host, extra) {
     if (!answer) continue;
     if (answer.status === 200 && answer.json.token) {
       say(`  ✓ Approved as "${answer.json.label}"${answer.json.account ? ` for the WorkTrust account ${answer.json.account}` : ""}`);
-      if (answer.json.account) say("    Not your account? Run `npx worktrust disconnect` now and revoke it in WorkTrust.");
+      if (answer.json.account) say("    Not your account? Run `npx worktrust@latest disconnect` now and revoke it in WorkTrust.");
       return paired(answer.json);
     }
     if (answer.json.error === "slow_down") wait += 2000;
@@ -354,7 +358,7 @@ function withLock(work) {
 /**
  * A KEY FILE ON OTHER HARDWARE (0.6.10, owner 2026-10-05: "a backup restored onto a new device must not upload to the
  * passport unseen"). The key file remembers the profile it was made on; on any other computer it sends nothing, and
- * WorkTrust is told once (`/api/cli/moved`), so the key is ended and the owner sees it. `npx worktrust connect` couples this one.
+ * WorkTrust is told once (`/api/cli/moved`), so the key is ended and the owner sees it. `npx worktrust@latest connect` couples this one.
  */
 async function copiedHere(key) {
   const here = computerIds().profile_id;
@@ -364,7 +368,7 @@ async function copiedHere(key) {
     const url = `${new URL(key.url).origin}/api/cli/moved`, body = JSON.stringify(computerIds());
     await fetch(url, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${key.token}`, ...proof(key.device, url, body) }, body });
   } catch { /* offline: it is told next time */ }
-  process.stderr.write("WorkTrust: this key was made on another computer (copied from a backup?). Nothing is sent from here; run `npx worktrust connect` on this computer.\n");
+  process.stderr.write("WorkTrust: this key was made on another computer (copied from a backup?). Nothing is sent from here; run `npx worktrust@latest connect` on this computer.\n");
   return true;
 }
 
@@ -431,7 +435,7 @@ async function bridge() {
     let message;
     try { message = JSON.parse(line); } catch { continue; }
     if (message.method === "initialize" && message.params?.clientInfo?.name) agent = `${message.params.clientInfo.name}/${message.params.clientInfo.version ?? "0"} (worktrust-bridge) worktrust-cli/${CLI_VERSION}`;
-    if (!key) { if (message.id !== undefined) answer(message.id, "WorkTrust is not connected on this computer: run `npx worktrust connect`."); continue; }
+    if (!key) { if (message.id !== undefined) answer(message.id, "WorkTrust is not connected on this computer: run `npx worktrust@latest connect`."); continue; }
     try {
       const response = await fetch(key.url, { method: "POST", headers: { "content-type": "application/json", accept: "application/json, text/event-stream", authorization: `Bearer ${key.token}`, "user-agent": agent, ...(session ? { "mcp-session-id": session } : {}), ...proof(key.device, key.url, line) }, body: line });
       session = response.headers.get("mcp-session-id") ?? session;
@@ -444,7 +448,7 @@ async function bridge() {
           const again = await fetch(key.url, { method: "POST", headers: { "content-type": "application/json", accept: "application/json, text/event-stream", authorization: `Bearer ${key.token}`, "user-agent": agent, ...(session ? { "mcp-session-id": session } : {}), ...proof(key.device, key.url, line) }, body: line });
           if (again.status !== 401) { const text = await again.text(); const parts = (again.headers.get("content-type") ?? "").includes("event-stream") ? text.split("\n").filter((part) => part.startsWith("data:")).map((part) => part.slice(5).trim()) : [text.trim()]; for (const part of parts.filter(Boolean)) process.stdout.write(`${part}\n`); continue; }
         }
-        answer(message.id, "WorkTrust did not accept this computer's key: run `npx worktrust connect` again.");
+        answer(message.id, "WorkTrust did not accept this computer's key: run `npx worktrust@latest connect` again.");
         continue;
       }
       const text = await response.text();
@@ -502,7 +506,7 @@ async function sessionEnd() {
 }
 
 /**
- * `npx worktrust update` (owner, 2026-10-04): THIS COMPUTER ONTO THE NEWEST CLI, WITHOUT PAIRING IT
+ * `npx worktrust@latest update` (owner, 2026-10-04): THIS COMPUTER ONTO THE NEWEST CLI, WITHOUT PAIRING IT
  * AGAIN. `connect` mints a new key and so a new device row to merge; an update keeps the key and the
  * row. It writes what `connect` writes after its pairing: the bridge copy in ~/.worktrust, every
  * WorkTrust entry in the AI apps taken out (a hand-made one with a key in it too) and the bridge put
@@ -611,12 +615,15 @@ async function connect() {
   if (switched) { say(); say("  Earlier work on this computer is not offered: it was coupled to another account before. Only work from now on goes to this account."); }
   else await offerHistory(paths, token, device ? device.privateKey.export({ format: "pem", type: "pkcs8" }) : null);
   say();
+  // ONE LINE, NO CHANGE (2026-10-06): Claude Code deletes what the hook measures from; `preserve --apply` keeps it, on a yes.
+  const keeps = claudeKeepsDays();
+  if (keeps !== null && keeps < 90) say(`  Claude Code deletes sessions after ${keeps} days. Keep them: npx worktrust@latest preserve --apply`);
   say("  Done. Quit your AI apps completely and open them again. This computer appears in WorkTrust");
   say("  under Sources → CLI once one of them has spoken.");
 }
 
 /**
- * EARLIER WORK IS SENT ONLY ON A YES (owner, 2026-10-03). After coupling, or as `npx worktrust history`:
+ * EARLIER WORK IS SENT ONLY ON A YES (owner, 2026-10-03). After coupling, or as `npx worktrust@latest history`:
  * what this computer holds is counted here and shown, and nothing leaves before the person types y.
  * 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).
@@ -630,9 +637,9 @@ async function offerHistory(paths, token, devicePem, url = MCP) {
   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 (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 history"); 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 history again: a line already received is kept once.");
+  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.");
 }
 
 async function history() {
@@ -789,10 +796,10 @@ function status() {
     for (const project of Object.values(config.projects ?? {})) Object.assign(servers, project.mcpServers ?? {});
   } catch { /* no Claude Code here */ }
   const door = Object.entries(servers).find(([name, server]) => /worktrust/i.test(`${name} ${server?.url ?? ""} ${(server?.args ?? []).join(" ")}`));
-  say(door ? `  Claude Code: coupled (${door[1].url ?? "through the local bridge"})` : "  Claude Code: not coupled. Run `npx worktrust connect`.");
+  say(door ? `  Claude Code: coupled (${door[1].url ?? "through the local bridge"})` : "  Claude Code: not coupled. Run `npx worktrust@latest connect`.");
   const key = keyStore.load();
   say(key ? `  Key: in ${KEY_PLACE}, ${key.device ? "bound to this computer, " : ""}last renewed ${String(key.renewedAt ?? "").slice(0, 10) || "never"}` : "  Key: not on this computer (or written into the apps' settings with --direct)");
-  if (key) say(key.account ? `  Account: ${key.account}${key.coupledAt ? `, coupled ${String(key.coupledAt).slice(0, 10)}` : ""}` : "  Account: not recorded (coupled by an older version; `npx worktrust connect` records it)");
+  if (key) say(key.account ? `  Account: ${key.account}${key.coupledAt ? `, coupled ${String(key.coupledAt).slice(0, 10)}` : ""}` : "  Account: not recorded (coupled by an older version; `npx worktrust@latest connect` records it)");
   let hook = false;
   try { hook = /log-session|worktrust\.mjs\\?" hook/.test(readFileSync(join(homedir(), ".claude", "settings.json"), "utf8")); } catch { /* none */ }
   say(hook ? "  Session hook: installed" : "  Session hook: not installed");
@@ -802,6 +809,23 @@ function status() {
   say(existsSync(join(HOME_DIR, "pinned")) ? "  Counter: from the package, pinned" : existsSync(join(HOME_DIR, "count-behaviour.mjs")) ? "  Counter: follows the site" : "  Counter: not installed");
 }
 
+/** Claude Code's `cleanupPeriodDays` (its default 30), or null without Claude Code here. Read only: preserve.mjs changes it, on a yes. */
+function claudeKeepsDays() {
+  if (!existsSync(join(homedir(), ".claude"))) return null;
+  try { const days = JSON.parse(readFileSync(join(homedir(), ".claude", "settings.json"), "utf8")).cleanupPeriodDays; return typeof days === "number" ? days : 30; } catch { return 30; }
+}
+
+/**
+ * KEEP YOUR HISTORY (`npx worktrust@latest preserve`, 2026-10-06): preserve.mjs beside this file, run as it is. Local only: no
+ * key, no account, no connection. From a single downloaded file it is not offered, since fetching it would be one.
+ */
+async function preserve() {
+  const script = join(HERE, "preserve.mjs");
+  if (!existsSync(script)) fail("preserve runs from the package: npx worktrust@latest preserve");
+  const child = spawn(process.execPath, [script, ...args.filter((arg) => arg !== "preserve")], { stdio: "inherit", env: { ...process.env, WORKTRUST_COLLECTOR: `worktrust-cli/${CLI_VERSION}` } });
+  process.exitCode = await new Promise((resolve) => child.on("exit", (code) => resolve(code ?? 1)));
+}
+
 function help() {
   say("WorkTrust: couple this computer to your record. Metadata only.");
   say();
@@ -818,12 +842,17 @@ function help() {
   say("  worktrust history      send this computer's earlier sessions as history (asks first)");
   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");
+  say("    --apply              keep them: asks per change, backs the file up first (--yes: no question)");
+  say("    --archive [dir]      a local, metadata-only, hash-chained record of the measured days (~/AI-Evidence)");
+  say("    --verify [dir]       check that record: every hash, the chain, each day's root and signature");
+  say("    --summary [dir]      hours, tokens per model, cache share and parallel sessions, counted from that record");
 }
 
 // THE BARE COMMAND COUPLES (owner, 2026-10-03: "zo kort mogelijk"). `npx worktrust` on a computer
 // without a key here shows the plan and asks, exactly as `connect` does; with one it says what is
 // coupled, so running it twice never re-pairs by surprise.
-if (command === "default") { if (keyStore.load()) { status(); say(); say("  This computer is coupled. `npx worktrust connect` couples it again; `npx worktrust disconnect` takes it out."); } else await connect(); }
+if (command === "default") { if (keyStore.load()) { status(); say(); say("  This computer is coupled. `npx worktrust@latest connect` couples it again; `npx worktrust@latest disconnect` takes it out."); } else await connect(); }
 else if (command === "mcp") await bridge();
 else if (command === "hook") await hook();
 else if (command === "connect") await connect();
@@ -840,4 +869,5 @@ else if (command === "codex") await offerCodex();
 else if (command === "antigravity") await offerAntigravity();
 else if (command === "disconnect") await disconnect();
 else if (command === "status") status();
+else if (command === "preserve") await preserve();
 else help();