worktrust 0.7.6 → 0.8.1

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
@@ -165,6 +167,7 @@ nothing it does not:
 | `context`, `routing` | how often the context was compacted and which context commands you used (compact, clear, resume, context, model, memory; never a command of your own), how many models answered and how often the model changed (0.7.4) |
 | `steering` | the moments you stepped in while the agent worked (stopping it, or a message mid-task), how many changed what the agent did next, and how many were followed by a passing check (0.7.5) |
 | `tools`, `complexity` | how many different tools the agent used, and the stretch's task complexity C1 to C5 by the rule complexity/1 (points for layers touched, tools, subagents, duration, a recovered failure, kinds of check and a delivery; the rule is in stretch-evidence.mjs), with its points and the rule's version (0.7.6) |
+| `oversight`, `planning`, `changes` | how often you refused an action or a plan the agent proposed, and how often a guard (the client's safety layer) refused one; how often the agent wrote its to-do list, the most items, and of the last list how many were done (never what they say); how many files the stretch's commits changed and how many of them tests (never a path) (0.8.1) |
 | `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 |
 
@@ -198,6 +201,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");
@@ -135,6 +135,8 @@ const DAY_SECONDS = 86400;
 const TOOL_CAP = 1800;
 /** Tools whose result waits for the person: the gap to it is the person's time. Names only; nothing of the call is read. */
 const WAITS_FOR_PERSON = new Set(["AskUserQuestion", "ExitPlanMode"]);
+/** A path that holds tests, by the conventions of the common test runners (read here; the path never leaves). */
+const TEST_PATH = /(^|[\\/])(__tests__|tests?|spec|e2e)[\\/]|\.(test|spec)\.[cm]?[jt]sx?$|_test\.(go|py|rb)$|(^|[\\/])test_[^\\/]+\.py$|Tests?\.(java|kt|cs|swift)$/;
 /** The derived record of a stretch, kept for the local archive only (see payloadFor). */
 const DERIVED = new WeakMap();
 const AGENT_RUNS_MAX = 10000, AGENT_SECONDS_MAX = 2592000;
@@ -211,7 +213,7 @@ const excluded = (path) => excludes.some((text) => text && path.includes(text));
 const { CODEX_ROLLOUT = /(?!)/, codexIdOf = (file) => String(file).split(/[\\/]/).at(-1).replace(/\.jsonl$/, ""), antigravityIdOf = (file) => String(file).split(/[\\/]/).at(-4), codexLines, codexRolloutFiles = function* () {}, codexCwd = () => null, ANTIGRAVITY_TRANSCRIPT = /(?!)/, antigravityLines, antigravityRoots = () => [], antigravityTranscripts = function* () {}, antigravityContext = () => ({}), rememberAntigravity = () => null } = (await import("./transcript-readers.mjs").catch(() => null)) ?? {};
 // THE STRETCH'S DERIVED RECORD (0.7.4: split from this file): tool calls named by kind, verification, recovery, delegation,
 // context and routing, for the local archive only. A copy without the module still measures and sends exactly as before.
-const { callOf = (block) => ({ id: block.id, kinds: [], family: String(block.name), digest: "" }), deriveStretch = () => ({}), complexityOf = null } = (await import("./stretch-evidence.mjs").catch(() => null)) ?? {};
+const { callOf = (block) => ({ id: block.id, kinds: [], family: String(block.name), digest: "" }), deriveStretch = () => ({}), complexityOf = null, resultOf = (block) => ({ id: block.tool_use_id, failed: block.is_error === true, refusal: null }) } = (await import("./stretch-evidence.mjs").catch(() => null)) ?? {};
 const { DATABASE_SESSION = /(?!)/, databaseLines = () => null, databaseSessions = function* () {} } = (await import("./session-databases.mjs").catch(() => null)) ?? {};
 const DATABASE_CLIENTS = ["hermes", "goose", "opencode", "openclaw", "cursor", "copilot"]; // the registry's keys, the name each line carries
 const LIVE_SOURCE = new RegExp(`^(codex|antigravity|${DATABASE_CLIENTS.join("|")}):`); // a sweep entry's id → the client it names (every database client, 0.6.16)
@@ -398,7 +400,7 @@ const messageOf = (line, at) => {
     // 0.7.1: each tool call's kinds (never its command) and each tool result's outcome, joined on the call's id in `measure`.
     // 0.7.2: and the call's FAMILY (the tool, and its check kinds) and a digest of its input, compared here and never kept.
     calls: line.type === "assistant" ? blocks.filter((block) => block && block.type === "tool_use" && typeof block.id === "string").map(callOf) : [],
-    results: blocks.filter((block) => block && block.type === "tool_result" && typeof block.tool_use_id === "string").map((block) => ({ id: block.tool_use_id, failed: block.is_error === true })),
+    results: blocks.filter((block) => block && block.type === "tool_result" && typeof block.tool_use_id === "string").map(resultOf),
   };
 };
 
@@ -624,7 +626,9 @@ function payloadFor(stretch) {
   };
   // WHAT STAYS ON THIS COMPUTER (0.7.1): the stretch's derived record rides beside the payload for the local archive, never in it.
   // 0.7.6: and the stretch's complexity class, read from what the hook knows here (layers, subagents, duration) and the record.
-  if (stretch.derived) DERIVED.set(payload, { ...stretch.derived, ...(complexityOf ? { complexity: complexityOf(stretch.derived, { layers: Math.max(layers.length, layer ? 1 : 0), agentRuns: stretch.agents?.runs ?? 0, agentPeak: stretch.agents?.peak ?? 0, seconds: stretch.seconds }) } : {}) });
+  // 0.8.1: what the stretch changed, as counts of files (never their paths): how many, and how many of them tests.
+  const changed = [...new Set(touched.paths)], tests = changed.filter((path) => TEST_PATH.test(path)).length;
+  if (stretch.derived) DERIVED.set(payload, { ...stretch.derived, ...(changed.length > 0 ? { changes: { files: changed.length, test_files: tests } } : {}), ...(complexityOf ? { complexity: complexityOf(stretch.derived, { layers: Math.max(layers.length, layer ? 1 : 0), agentRuns: stretch.agents?.runs ?? 0, agentPeak: stretch.agents?.peak ?? 0, seconds: stretch.seconds }) } : {}) });
   return payload;
 }
 
@@ -658,6 +662,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 +937,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.1",
   "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");
@@ -83,6 +83,14 @@ export function archiveLine(entry, behaviour = null, { ids = {}, collector } = {
   // TOOL BREADTH AND COMPLEXITY (0.7.6): distinct tools; a class C1–C5 with its points and the rule's version.
   if (whole(entry.tools) && entry.tools > 0) line.tools = entry.tools;
   if (entry.complexity && /^C[1-5]$/.test(entry.complexity.class ?? "") && whole(entry.complexity.points) && /^complexity\/\d+$/.test(entry.complexity.rule ?? "")) line.complexity = { class: entry.complexity.class, points: entry.complexity.points, rule: entry.complexity.rule };
+  // OVERSIGHT, PLANNING AND CHANGES (0.8.1): refusals by the person and by a guard; the agent's to-do lists; files changed and test files among them.
+  const pick = (record, keys) => (record && typeof record === "object" && keys.every((key) => whole(record[key])) ? Object.fromEntries(keys.map((key) => [key, record[key]])) : null);
+  const oversight = pick(entry.oversight, ["refused", "plans_rejected", "guard_denied"]);
+  if (oversight) line.oversight = oversight;
+  const planning = pick(entry.planning, ["lists", "items_max", "items_last", "done_last"]);
+  if (planning && planning.lists > 0 && planning.done_last <= planning.items_last && planning.items_last <= planning.items_max) line.planning = planning;
+  const changes = pick(entry.changes, ["files", "test_files"]);
+  if (changes && changes.test_files <= changes.files) line.changes = changes;
   // The behaviour signals of this stretch (0.7.0): keys of the counter's rubric and whole counts, never a word of a turn.
   if (behaviour && behaviour.signals && typeof behaviour.analyzer_version === "string" && /^counter@\d+\.\d+\.\d+$/.test(behaviour.analyzer_version)) {
     const kept = Object.entries(behaviour.signals).filter(([key, count]) => SIGNAL.test(key) && Number.isInteger(count) && count > 0).sort();
@@ -91,3 +99,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/stretch-evidence.mjs

@@ -32,8 +32,23 @@ export const callKindsOf = (block) => {
   const command = block && SHELL_TOOLS.has(String(block.name)) ? block.input?.command ?? block.input?.CommandLine ?? block.input?.cmd : null;
   return typeof command === "string" ? CALL_KINDS.filter(([, pattern]) => pattern.test(command)).map(([kind]) => kind) : [];
 };
+/**
+ * A TOOL RESULT AS THE STRETCH READS IT (0.8.1): its call's id, whether it failed, and, read here and never kept, WHO
+ * refused it when it was refused: the PERSON (Claude Code's fixed sentence when they decline a tool use or a plan) or a
+ * GUARD (the client's own safety layer or auto-mode classifier). Framework L8 and L5.
+ */
+const PERSON_REFUSED = /^\s*(The user doesn't want to (proceed|take this action)|User rejected|The user rejected|The user declined)/i;
+const GUARD_REFUSED = /^\s*Permission for this (command|action) was denied by/i;
+export const resultOf = (block) => {
+  const text = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map((part) => (part && typeof part.text === "string" ? part.text : "")).join("") : "";
+  const failed = block.is_error === true;
+  return { id: block.tool_use_id, failed, refusal: failed && PERSON_REFUSED.test(text) ? "person" : failed && GUARD_REFUSED.test(text) ? "guard" : null };
+};
+/** A to-do list the agent wrote (TodoWrite): how many items and how many done, never what they say. */
+const planOf = (block) => (block.name === "TodoWrite" && Array.isArray(block.input?.todos) ? { items: block.input.todos.length, done: block.input.todos.filter((todo) => todo && todo.status === "completed").length } : null);
+
 /** One tool call as the stretch reads it: its id, its kinds, its FAMILY (the tool and its check kinds) and a digest of its input (compared, never kept). */
-export const callOf = (block) => { const kinds = callKindsOf(block); return { id: block.id, kinds, family: `${String(block.name)}|${kinds.join("+")}`, digest: createHash("sha256").update(JSON.stringify(block.input ?? null)).digest("base64url").slice(0, 16) }; };
+export const callOf = (block) => { const kinds = callKindsOf(block), plan = planOf(block); return { id: block.id, kinds, family: `${String(block.name)}|${kinds.join("+")}`, digest: createHash("sha256").update(JSON.stringify(block.input ?? null)).digest("base64url").slice(0, 16), ...(plan ? { plan } : {}) }; };
 
 /**
  * VERIFICATION PER STRETCH (0.7.1; framework L7, L12): per kind of check, how many ran and how many failed; per step of
@@ -194,9 +209,32 @@ export function complexityOf(derived, { layers = 0, agentRuns = 0, agentPeak = 0
 /** How many different tools the stretch's agent used (framework L11: tool breadth); null without a tool call. */
 const toolsOf = (messages) => { const names = new Set(); for (const message of messages) for (const call of message.calls ?? []) names.add(call.family.split("|")[0]); return names.size > 0 ? names.size : null; };
 
+/**
+ * OVERSIGHT AND PLANNING PER STRETCH (0.8.1; framework L8, L5, L2). Oversight: how often the PERSON refused an action
+ * or a plan the agent proposed, and how often a GUARD (the client's safety layer) refused one. Planning: how often the
+ * agent wrote its to-do list, the most items one list held, and of the last list how many were done. Null where none.
+ */
+function oversightOf(messages) {
+  let person = 0, plans = 0, guard = 0;
+  const tools = new Map();
+  for (const message of messages) for (const call of message.calls ?? []) tools.set(call.id, call.family.split("|")[0]);
+  for (const message of messages) for (const result of message.results ?? []) {
+    if (result.refusal === "person") { if (tools.get(result.id) === "ExitPlanMode") plans += 1; else person += 1; }
+    if (result.refusal === "guard") guard += 1;
+  }
+  return person + plans + guard > 0 ? { refused: person, plans_rejected: plans, guard_denied: guard } : null;
+}
+function planningOf(messages) {
+  const lists = [];
+  for (const message of messages) for (const call of message.calls ?? []) if (call.plan) lists.push(call.plan);
+  if (lists.length === 0) return null;
+  const last = lists.at(-1);
+  return { lists: lists.length, items_max: Math.max(...lists.map((list) => list.items)), items_last: last.items, done_last: last.done };
+}
+
 /** The stretch's whole derived record; `helpers` are the hook's own readers of a human turn, so both read it the same way. */
 export function deriveStretch(messages, helpers) {
   const context = contextOf(messages, helpers), routing = routingOf(messages), steering = steeringOf(messages, helpers);
-  const tools = toolsOf(messages);
-  return { ...verificationOf(messages, helpers), ...(context ? { context } : {}), ...(routing ? { routing } : {}), ...(steering ? { steering } : {}), ...(tools ? { tools } : {}) };
+  const tools = toolsOf(messages), oversight = oversightOf(messages), planning = planningOf(messages);
+  return { ...(oversight ? { oversight } : {}), ...(planning ? { planning } : {}), ...verificationOf(messages, helpers), ...(context ? { context } : {}), ...(routing ? { routing } : {}), ...(steering ? { steering } : {}), ...(tools ? { tools } : {}) };
 }

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.1";
 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");