worktrust 0.7.1 → 0.7.3

package/README.md

@@ -160,6 +160,8 @@ nothing it does not:
 | `device_id`, `profile_id` | which computer and which user profile on it, as one-way hashes (the machine's own id never appears) |
 | `signals`, `analyzer_version` | the behaviour signals of that stretch as keys and counts from the local counter's rubric (framing, steering, verification, recovery), and the rubric's version; derived on this computer from your own turns, never a word of them (0.7.0) |
 | `verification`, `delivery` | per kind of check run in the stretch (test, typecheck, lint, build, the project's gate, CI) how many ran and how many failed; per delivery step (commit, PR, push, deploy) how many succeeded, and whether a check had passed before the first; named from each command on this computer, never the command itself (0.7.1) |
+| `recovery` | of the tool calls that failed in the stretch, how many a later call of the same kind recovered, the middle time that took, how many were retried unchanged and how many with a different approach; inputs compared on this computer by digest, never kept (0.7.2) |
+| `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) |
 | `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 |
 

package/log-session.mjs

@@ -415,7 +415,8 @@ const messageOf = (line, at) => {
     waitsForPerson: line.type === "assistant" && blocks.some((block) => block && block.type === "tool_use" && WAITS_FOR_PERSON.has(String(block.name))),
     agentic: line.agentic === true, cumulative: line.cumulative === true, // the session's running totals (Hermes, Goose without a ledger)
     // 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`.
-    calls: line.type === "assistant" ? blocks.filter((block) => block && block.type === "tool_use" && typeof block.id === "string").map((block) => ({ id: block.id, kinds: callKindsOf(block) })).filter((call) => call.kinds.length > 0) : [],
+    // 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((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) }; }) : [],
     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 })),
   };
 };
@@ -511,7 +512,63 @@ function verificationOf(messages) {
     }
   }
   const any = (record) => Object.keys(record).length > 0;
-  return { ...(any(checks) ? { verification: checks } : {}), ...(any(delivered) ? { delivery: { ...delivered, verified_first: passedFirst } } : {}) };
+  const recovery = recoveryOf(messages), delegation = delegationOf(messages);
+  return { ...(any(checks) ? { verification: checks } : {}), ...(any(delivered) ? { delivery: { ...delivered, verified_first: passedFirst } } : {}), ...(recovery ? { recovery } : {}), ...(delegation ? { delegation } : {}) };
+}
+
+/**
+ * DELEGATION AND CHECKPOINTS PER STRETCH (0.7.3; framework L3, L5): how many tool actions the agent took on its own
+ * between two moments the person stepped in (their own turn, or stopping it), as the longest and the middle chain; and
+ * how often the agent stopped for the person on purpose: a question it asked them, a plan it asked them to approve.
+ * Null when the stretch made no tool call.
+ */
+function delegationOf(messages) {
+  const chains = [];
+  let chain = 0, calls = 0, questions = 0, plans = 0;
+  for (const message of messages) {
+    if (message.bridge) continue;
+    const stepIn = message.type === "user" && !message.meta && message.kind !== "tool_result" && (isHumanTurn(message.content) || INTERRUPTED.test(textOf(message.content).trim()));
+    if (stepIn) { if (chain > 0) chains.push(chain); chain = 0; continue; }
+    for (const call of message.calls ?? []) {
+      const tool = call.family.split("|")[0];
+      calls += 1; chain += 1;
+      if (tool === "AskUserQuestion") questions += 1;
+      if (tool === "ExitPlanMode") plans += 1;
+    }
+  }
+  if (chain > 0) chains.push(chain);
+  if (calls === 0) return null;
+  chains.sort((a, b) => a - b);
+  return { chain_max: chains.at(-1), chain_median: chains[Math.floor((chains.length - 1) / 2)], questions, plans };
+}
+
+/**
+ * RECOVERY PER STRETCH (0.7.2; framework L9): of the tool calls that failed, how many were followed by a success of the
+ * same family (the same tool, the same kind of check) later in the stretch, the middle time that took, and what came
+ * next: the same input again (a blind retry) or a different one (a changed strategy). Inputs are compared by digest on
+ * this computer and never kept. Null when nothing failed.
+ */
+function recoveryOf(messages) {
+  const calls = [];
+  const byId = new Map();
+  for (const message of messages) {
+    for (const call of message.calls ?? []) { const entry = { ...call, at: message.at, failed: null }; calls.push(entry); byId.set(call.id, entry); }
+    for (const result of message.results ?? []) { const call = byId.get(result.id); if (call) call.failed = result.failed; }
+  }
+  const done = calls.filter((call) => call.failed !== null);
+  let failures = 0, recovered = 0, blind = 0, changed = 0;
+  const latencies = [];
+  done.forEach((call, index) => {
+    if (!call.failed) return;
+    failures += 1;
+    const later = done.slice(index + 1).filter((next) => next.family === call.family);
+    if (later.length > 0) { if (later[0].digest === call.digest) blind += 1; else changed += 1; }
+    const success = later.find((next) => !next.failed);
+    if (success) { recovered += 1; latencies.push(Math.max(0, Math.round((success.at - call.at) / 1000))); }
+  });
+  if (failures === 0) return null;
+  latencies.sort((a, b) => a - b);
+  return { failures, recovered, blind_retries: blind, strategy_changed: changed, ...(latencies.length ? { median_seconds: latencies[Math.floor((latencies.length - 1) / 2)] } : {}) };
 }
 
 /** One day's messages → the stretch, measured. Null when there is nothing honest to send. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "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

@@ -58,6 +58,16 @@ export function archiveLine(entry, behaviour = null, { ids = {}, collector } = {
     const kept = Object.entries(entry.delivery).filter(([kind, count]) => DELIVERY_KINDS.includes(kind) && whole(count) && count > 0).sort();
     if (kept.length > 0) line.delivery = { ...Object.fromEntries(kept), verified_first: entry.delivery.verified_first === true };
   }
+  // RECOVERY (0.7.2): failures, recoveries, blind retries, changed strategies and the middle time to recover, whole numbers.
+  if (entry.recovery && typeof entry.recovery === "object") {
+    const { failures, recovered, blind_retries: blind, strategy_changed: changed, median_seconds: median } = entry.recovery;
+    if ([failures, recovered, blind, changed].every(whole) && failures > 0 && recovered <= failures && blind + changed <= failures && (median === undefined || whole(median))) line.recovery = { failures, recovered, blind_retries: blind, strategy_changed: changed, ...(median !== undefined ? { median_seconds: median } : {}) };
+  }
+  // DELEGATION (0.7.3): the longest and middle chain of the agent's own actions between the person's steps, questions, plans.
+  if (entry.delegation && typeof entry.delegation === "object") {
+    const { chain_max: most, chain_median: middle, questions, plans } = entry.delegation;
+    if ([most, middle, questions, plans].every(whole) && most > 0 && middle <= most) line.delegation = { chain_max: most, chain_median: middle, questions, plans };
+  }
   // 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();

package/worktrust.mjs

@@ -71,7 +71,7 @@ const command = args.find((arg, at) => !arg.startsWith("--") && !(at > 0 && VALU
 const flag = (name) => { const at = args.indexOf(`--${name}`); return at >= 0 ? args[at + 1] : undefined; };
 const has = (name) => args.includes(`--${name}`);
 /** This CLI's version, said to the door so the app can tell which computer runs an old one (check-cli-package holds it equal to package.json). */
-const CLI_VERSION = "0.7.1";
+const CLI_VERSION = "0.7.3";
 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");