worktrust 0.7.6 → 0.8.0

package/README.md

@@ -81,6 +81,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@latest history --from-archive [dir]   send what your local archive holds of sessions your AI apps
+                                   already deleted, marked as from your archive (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
@@ -198,6 +200,13 @@ and more AI apps (Cursor, Copilot, Hermes, Goose, OpenCode, OpenClaw, Codex, Ant
 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 --from-archive` (0.8.0) is for the sessions an AI app has already deleted (Claude
+Code's default is 30 days). It sends what your local archive (`preserve --archive`) holds of them, and only that: days
+this computer signed with its own key, of sessions no longer on the computer, each line marked as coming from your
+archive. It refuses, and sends nothing, when the computer has no device key, when the archive does not verify, or when
+WorkTrust does not yet accept the mark. It shows the plan first and asks once; Enter is No. Such lines are history,
+like any import: never verified hours.
+
 `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.
 

package/log-session.mjs

@@ -54,12 +54,12 @@
  * CONFIDENTIAL PROJECTS never open: `~/.worktrust-counter.json` { "exclude": ["client-x"] } is
  * honoured here too, matched against the transcript's project directory, before a file is read.
  */
-import { execFileSync, spawn } from "node:child_process";
+import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createHash, randomBytes, sign as cryptoSign } from "node:crypto";
+import { createHash, createPrivateKey, createPublicKey, randomBytes, sign as cryptoSign } from "node:crypto";
 
 const args = process.argv.slice(2);
 const flag = (name) => args.includes(`--${name}`), value = (name) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : undefined; }, DRY = flag("dry-run");
@@ -658,6 +658,19 @@ async function sendHistory(door, entries, announce = false, rebuild = false) {
   return accepted;
 }
 
+/** Whether the door's import_history takes `from_archive` (0.8.0): asked with tools/list, never assumed. */
+async function doorKnowsArchive(target) {
+  if (!target) return false;
+  try {
+    const body = JSON.stringify({ jsonrpc: "2.0", id: 0, method: "tools/list" });
+    const response = await fetch(target.url, { method: "POST", headers: { "content-type": "application/json", accept: "application/json, text/event-stream", authorization: `Bearer ${target.token}`, ...proofFor(target.url, body) }, body });
+    const text = await response.text();
+    const json = JSON.parse(text.trim().startsWith("{") ? text : text.split("\n").find((row) => row.startsWith("data:"))?.slice(5) ?? "null");
+    const tool = json?.result?.tools?.find((one) => one.name === "import_history");
+    return Boolean(tool?.inputSchema?.properties?.entries?.items?.properties?.from_archive);
+  } catch { return false; }
+}
+
 /** DEVICE PROOF (2026-10-03): through `worktrust hook` a bound computer hands over WORKTRUST_DEVICE_KEY; every call is then signed. */
 const proofFor = (url, body) => {
   const device = process.env.WORKTRUST_DEVICE_KEY;
@@ -920,6 +933,32 @@ const entryFile = new WeakMap(); // a history entry → its transcript (`--summa
 if (flag("archive-lines")) { const lines = historyEntries(null, true).map((entry) => JSON.stringify({ ...entry, ...(DERIVED.get(entry) ?? {}), client: entrySource.get(entry) ?? "claude", started_at: new Date(entryFile.get(entry).from).toISOString(), folder: entryFile.get(entry).folder })); process.stdout.write(`${[...lines, JSON.stringify({ archive_end: lines.length })].join("\n")}\n`); await exitFlushed(0); } // one write and a count, so the reader tells a whole answer from a cut one
 if (!door && !codexDoor && !DRY) { process.exit(0); } // Not coupled on this machine: nothing to do, quietly.
 
+/**
+ * HISTORY FROM THE ARCHIVE (0.8.0; framework §22). When an AI app has deleted its sessions, the stretches this computer
+ * archived (`preserve --archive`) can still be filed, marked `from_archive`. Five conditions, each refused by name: a
+ * device key (only lines this computer signed travel), an archive that verifies, a stretch whose session is gone from
+ * this computer (one still here goes through the ordinary history), a door that knows the mark, and the person asking.
+ */
+if (flag("history") && flag("from-archive")) {
+  const named = value("from-archive"), dir = named && !named.startsWith("--") ? named.replace(/^~(?=\/|$)/, homedir()) : join(homedir(), "AI-Evidence");
+  const say = (text) => console.log(text);
+  const pem = process.env.WORKTRUST_DEVICE_KEY;
+  let ownKey = null;
+  try { ownKey = pem ? createPublicKey(createPrivateKey(pem)).export({ format: "jwk" }).x : null; } catch { ownKey = null; }
+  if (!ownKey) { say("No device key on this computer: only lines this computer signed can be sent from its archive. Nothing was sent."); await exitFlushed(1); }
+  const verified = spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), "preserve.mjs"), "--verify", dir], { encoding: "utf8" });
+  if (verified.status !== 0) { say(`The archive in ${dir} does not verify, so nothing was sent: ${(verified.stdout || verified.stderr || "").trim().split("\n").pop()}`); await exitFlushed(1); }
+  const { archiveEntries = null } = (await import("./preserve-lines.mjs").catch(() => null)) ?? {};
+  if (!archiveEntries) { say("preserve-lines.mjs is not beside this file. Nothing was sent."); await exitFlushed(1); }
+  const present = new Set(historyEntries(null, true).map((entry) => entry.stretch_ref));
+  const signed = archiveEntries(dir, ownKey), gone = signed.filter(({ entry }) => !present.has(entry.stretch_ref));
+  const entries = gone.map(({ entry, client }) => { if (client !== "claude") entrySource.set(entry, client); return entry; });
+  say(`${signed.length} stretches in the archive signed by this computer · ${entries.length} of them no longer in any AI app here`);
+  if (DRY || entries.length === 0) { if (entries[0]) say(`\nthe oldest of them, in full:\n${JSON.stringify(entries[0], null, 1)}`); say(entries.length === 0 ? "Nothing to send." : "\ndry run — nothing sent."); await exitFlushed(0); }
+  if (!(await doorKnowsArchive(door))) { say("WorkTrust does not accept history from an archive yet (the door does not know the mark). Nothing was sent."); await exitFlushed(1); }
+  await exitFlushed((await sendHistory(door, entries, true)) === entries.length ? 0 : 1);
+}
+
 if (flag("history")) {
   const historyFloor = floorOf(readState(), "__historyFloor");
   const entries = historyEntries(historyFloor);

package/package.json

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

@@ -5,7 +5,7 @@
  */
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 
 const sha256 = (text) => createHash("sha256").update(text).digest("hex");
@@ -91,3 +91,34 @@ export function archiveLine(entry, behaviour = null, { ids = {}, collector } = {
   return { ...line, stretch_ref: entry.stretch_ref, ...ids, collector_version: collector };
 }
 
+
+/**
+ * THE ARCHIVE AS HISTORY (0.8.0; framework §22: "preserve as evidence continuity"). The lines of an archive this
+ * computer wrote AND signed (a day whose proof carries this computer's key), as `import_history` entries, each marked
+ * `from_archive` so the record shows it came from the person's own archive after the AI app had deleted the session.
+ * The caller verifies the archive first, sends only stretches whose session is gone, and only to a door that knows the
+ * mark. Nothing here sends.
+ */
+const read = (file) => { try { return JSON.parse(readFileSync(file, "utf8")); } catch { return null; } };
+const readdir = (dir) => { try { return readdirSync(dir); } catch { return []; } };
+export function archiveEntries(dir, ownKey) {
+  const out = [];
+  for (const year of readdir(dir).filter((name) => /^\d{4}$/.test(name)).sort()) for (const month of readdir(join(dir, year)).filter((name) => /^\d{2}$/.test(name)).sort()) {
+    const file = join(dir, year, month, "stretches.jsonl");
+    if (!existsSync(file)) continue;
+    for (const text of readFileSync(file, "utf8").split("\n").filter(Boolean)) {
+      let line; try { line = JSON.parse(text); } catch { continue; }
+      const proof = read(join(dir, "proofs", `${line.day}.json`));
+      if (!ownKey || !proof || typeof proof.signature !== "string" || proof.public_key !== ownKey) continue;
+      const entry = {
+        title: line.layer ? `AI-assisted work · ${line.layer}` : "AI-assisted work",
+        ...(line.kind ? { kind: line.kind } : {}), ...(line.layer ? { layer: line.layer } : {}), ...(line.layers ? { layers: line.layers } : {}),
+        ...(typeof line.seconds === "number" ? { seconds: line.seconds, duration_basis: line.duration_basis ?? "measured" } : {}),
+        ...Object.fromEntries(["tokens_in", "tokens_out", "token_basis", "tokens_cache_read", "tokens_cache_write", "exchanges", "turn_basis", "model", "steered_from", "model_seconds", "tool_seconds", "human_seconds", "idle_seconds", "agent_runs", "agent_seconds", "agent_peak", "interrupts", "steers", "utc_offset"].filter((key) => line[key] !== undefined).map((key) => [key, line[key]])),
+        stretch_ref: line.stretch_ref, started_at: line.started_at, at: line.ended_at, from_archive: true,
+      };
+      out.push({ entry, client: line.client ?? "claude" });
+    }
+  }
+  return out;
+}

package/worktrust.mjs

@@ -12,6 +12,8 @@
  *   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 history --from-archive [dir]   send what your local archive holds of sessions your AI apps have
+ *                                              already deleted, marked as from your archive (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,
@@ -71,7 +73,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.7.6";
+const CLI_VERSION = "0.8.0";
 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");
@@ -681,9 +683,27 @@ async function offerRebuild(previousVersion, paths, key) {
 async function history() {
   const key = await freshKey();
   if (!key) fail("this computer is not coupled through the key file. Run npx worktrust first.");
+  if (has("from-archive")) return offerArchive(await scripts(), key);
   await offerHistory(await scripts(), key.token, key.device ?? null, key.url, has("rebuild"));
 }
 
+/**
+ * THE ARCHIVE AS HISTORY (0.8.0): the plan first (how many signed stretches, how many of them gone from the AI apps
+ * here), then one question, Enter is No; the hook refuses by name whatever does not hold (no device key, an archive
+ * that does not verify, a door that does not know the mark).
+ */
+async function offerArchive(paths, key) {
+  const at = process.argv.indexOf("--from-archive"), named = process.argv[at + 1], dir = named && !named.startsWith("--") ? [named] : [];
+  const env = { WORKTRUST_MCP_URL: key.url, ...(key.device ? { WORKTRUST_DEVICE_KEY: key.device } : {}) };
+  const plan = await run(paths["log-session.mjs"], ["--history", "--from-archive", ...dir, "--dry-run"], key.token, true, env);
+  say();
+  for (const line of plan.out.trim().split("\n").filter((text) => !text.startsWith(" ") && !text.startsWith("{") && !text.startsWith("}") && text.trim())) say(`  ${line}`);
+  if (plan.code !== 0 || /Nothing to send/.test(plan.out) || has("dry-run")) return;
+  if (!(await ask("Send them as history, marked as from your archive?", false))) { say("  Not sent."); return; }
+  const sent = await run(paths["log-session.mjs"], ["--history", "--from-archive", ...dir], key.token, true, env);
+  say(sent.code === 0 ? "  ✓ Sent as history from your archive. It shows in WorkTrust as earlier work, marked as such, never as verified hours." : `  Not sent: ${sent.out.trim().split("\n").pop()}`);
+}
+
 /**
  * CODEX WAKES THE HOOK ON A YES (owner, 2026-10-04). Codex has no hook settings: it runs ONE `notify`
  * program at the end of every turn, named on a top-level line of ~/.codex/config.toml. Without it
@@ -878,6 +898,8 @@ function help() {
   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("    --from-archive [dir] send what your archive (preserve --archive) holds of sessions your AI apps already deleted,");
+  say("                         only days this computer signed, marked as from your archive (shows the plan, 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");