worktrust 0.7.5 → 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
@@ -164,6 +166,7 @@ nothing it does not:
 | `delegation` | the longest and the middle chain of actions the agent took on its own between your turns (or your stopping it), and how often it stopped to ask you a question or to have a plan approved (0.7.3) |
 | `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) |
 | `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 |
 
@@ -197,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");
@@ -211,7 +211,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 = () => ({}) } = (await import("./stretch-evidence.mjs").catch(() => null)) ?? {};
+const { callOf = (block) => ({ id: block.id, kinds: [], family: String(block.name), digest: "" }), deriveStretch = () => ({}), complexityOf = 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)
@@ -623,7 +623,8 @@ function payloadFor(stretch) {
     at: new Date(stretch.to).toISOString(),
   };
   // WHAT STAYS ON THIS COMPUTER (0.7.1): the stretch's derived record rides beside the payload for the local archive, never in it.
-  if (stretch.derived) DERIVED.set(payload, stretch.derived);
+  // 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 }) } : {}) });
   return payload;
 }
 
@@ -657,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;
@@ -919,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.5",
+  "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");
@@ -80,6 +80,9 @@ export function archiveLine(entry, behaviour = null, { ids = {}, collector } = {
     const { moments, changed_course: changed, effective } = entry.steering;
     if ([moments, changed, effective].every(whole) && moments > 0 && changed <= moments && effective <= changed) line.steering = { moments, changed_course: changed, effective };
   }
+  // 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 };
   // 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();
@@ -88,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/stretch-evidence.mjs

@@ -171,8 +171,32 @@ function steeringOf(messages, { isHumanTurn, INTERRUPTED, textOf }) {
   return { moments: moments.length, changed_course: changed.length, effective: changed.filter((moment) => moment.effective).length };
 }
 
+/**
+ * TASK COMPLEXITY C1 TO C5 (0.7.6; framework §14 "Task complexity C1-C5"), by a VERSIONED rule, `complexity/1`, every
+ * point of it stated here and in the README so anyone can recount a class. Proposed, not calibrated: it weighs evidence,
+ * it is not a score of anyone.
+ *   layers touched          ≤1: 0 · 2: 1 · 3+: 2          distinct tools used     <3: 0 · 3–6: 1 · 7+: 2
+ *   subagents               none: 0 · ran: 1 · 3+ at once: 2
+ *   measured duration       <30 min: 0 · 30–120 min: 1 · >120 min: 2
+ *   a failure recovered     1                              kinds of check run      0: 0 · 1–2: 1 · 3+: 2
+ *   something delivered     1
+ *   points 0–1 → C1 · 2–3 → C2 · 4–6 → C3 · 7–9 → C4 · 10+ → C5
+ */
+export const COMPLEXITY_RULE = "complexity/1";
+export function complexityOf(derived, { layers = 0, agentRuns = 0, agentPeak = 0, seconds = null } = {}) {
+  const step = (value, low, high) => (value >= high ? 2 : value >= low ? 1 : 0);
+  const points = step(layers, 2, 3) + step(derived.tools ?? 0, 3, 7) + (agentPeak >= 3 ? 2 : agentRuns > 0 ? 1 : 0)
+    + (seconds === null ? 0 : seconds > 7200 ? 2 : seconds >= 1800 ? 1 : 0) + ((derived.recovery?.recovered ?? 0) > 0 ? 1 : 0)
+    + step(Object.keys(derived.verification ?? {}).length, 1, 3) + (derived.delivery ? 1 : 0);
+  const tier = points >= 10 ? 5 : points >= 7 ? 4 : points >= 4 ? 3 : points >= 2 ? 2 : 1;
+  return { class: `C${tier}`, points, rule: COMPLEXITY_RULE };
+}
+/** 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; };
+
 /** 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);
-  return { ...verificationOf(messages, helpers), ...(context ? { context } : {}), ...(routing ? { routing } : {}), ...(steering ? { steering } : {}) };
+  const tools = toolsOf(messages);
+  return { ...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.5";
+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");