worktrust 0.7.0 → 0.7.2

package/README.md

@@ -159,6 +159,8 @@ nothing it does not:
 | `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) |
 | `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) |
 | `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

@@ -135,6 +135,33 @@ 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"]);
+/**
+ * WHAT A TOOL CALL WAS, AS A CATEGORY (0.7.1, verification per stretch; the capability roadmap's second tranche). A shell
+ * command is read HERE to name its kind: a check (test, typecheck, lint, build, CI, the project's own gate) or a step of
+ * delivery (commit, PR, push, deploy). The command itself never leaves this function; only the kind does, and only into
+ * the local archive. A chained command can be several kinds; its one outcome counts for each.
+ */
+const SHELL_TOOLS = new Set(["Bash", "bash", "shell", "run_command", "run_shell_command", "execute_command", "terminal"]);
+const CALL_KINDS = [
+  ["test", /(^|[\s/;&|])(vitest|jest|pytest|mocha|rspec|phpunit)\b|\b(npm|pnpm|yarn|bun)\s+(run\s+)?test\b|\bgo test\b|\bcargo test\b|\bnode --test\b|\bplaywright test\b|scripts\/test-[\w-]+\.m?[jt]s\b/],
+  ["typecheck", /\btsc\b|\b(npm|pnpm|yarn|bun)\s+(run\s+)?typecheck\b|\bmypy\b|\bpyright\b/],
+  ["lint", /\beslint\b|\b(npm|pnpm|yarn|bun)\s+(run\s+)?lint\b|\bruff\b|\bflake8\b|\bclippy\b|\bbiome\s+(check|lint)\b/],
+  ["build", /\b(npm|pnpm|yarn|bun)\s+(run\s+)?build\b|\bnext build\b|\bvite build\b|\bcargo build\b|\bgo build\b/],
+  ["gate", /\b(npm|pnpm|yarn|bun)\s+(run\s+)?(gate|verify|check)\b|scripts\/check-[\w-]+\.m?[jt]s\b/],
+  ["ci", /\bgh\s+(run\s+(watch|view)|pr\s+checks)\b/],
+  ["commit", /\bgit\s+commit\b/],
+  ["pr", /\bgh\s+pr\s+(create|merge)\b/],
+  ["push", /\bgit\s+push\b/],
+  ["deploy", /\b(vercel(\s+deploy)?\s+--prod|fly\s+deploy|netlify\s+deploy|wrangler\s+deploy)\b/],
+];
+const CHECK_KINDS = ["test", "typecheck", "lint", "build", "gate", "ci"];
+const DELIVERY_KINDS = ["commit", "pr", "push", "deploy"];
+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) : [];
+};
+/** 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;
 
 /**
@@ -387,6 +414,10 @@ const messageOf = (line, at) => {
     // 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, 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`.
+    // 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 })),
   };
 };
 
@@ -464,6 +495,56 @@ function isHumanTurn(content) {
   return types.has("text") || types.has("image");
 }
 
+/**
+ * VERIFICATION PER STRETCH (0.7.1; framework L7, L12): per kind of check, how many ran and how many failed; per step of
+ * delivery, how many succeeded; and whether a check had PASSED before the first delivery step. Null where the stretch
+ * ran neither, so "no check seen" is never written as "zero checks".
+ */
+function verificationOf(messages) {
+  const kinds = new Map();
+  for (const message of messages) for (const call of message.calls ?? []) kinds.set(call.id, call.kinds);
+  const checks = {}, delivered = {};
+  let deliveredAt = null, passedFirst = false;
+  for (const message of messages) for (const result of message.results ?? []) {
+    for (const kind of kinds.get(result.id) ?? []) {
+      if (CHECK_KINDS.includes(kind)) { const tally = (checks[kind] ??= [0, 0]); tally[0] += 1; if (result.failed) tally[1] += 1; else if (deliveredAt === null) passedFirst = true; }
+      else if (DELIVERY_KINDS.includes(kind) && !result.failed) { delivered[kind] = (delivered[kind] ?? 0) + 1; if (deliveredAt === null) deliveredAt = message.at; }
+    }
+  }
+  const any = (record) => Object.keys(record).length > 0;
+  const recovery = recoveryOf(messages);
+  return { ...(any(checks) ? { verification: checks } : {}), ...(any(delivered) ? { delivery: { ...delivered, verified_first: passedFirst } } : {}), ...(recovery ? { recovery } : {}) };
+}
+
+/**
+ * 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. */
 function measure(cwd, messages) {
   // MEASURED, AND ONLY MEASURED: every second counted lies between two recorded timestamps, and a
@@ -494,7 +575,7 @@ function measure(cwd, messages) {
     else if (isHumanTurn(message.content) && (prev.kind === "tool_result" || prev.toolUse)) steers += 1;
   }
   const from = firstOf(messages);
-  return { cwd, seconds: measured, layers: measured !== null ? timeLayers(messages) : null, ...tokens, cumulative: messages.some((message) => message.cumulative), exchanges, interrupts, steers, model, from, to: messages[messages.length - 1].at, offset: offsetAt(from) };
+  return { cwd, seconds: measured, derived: verificationOf(messages), layers: measured !== null ? timeLayers(messages) : null, ...tokens, cumulative: messages.some((message) => message.cumulative), exchanges, interrupts, steers, model, from, to: messages[messages.length - 1].at, offset: offsetAt(from) };
 }
 
 /**
@@ -579,7 +660,7 @@ function payloadFor(stretch) {
   // The seventh kind, used as it is defined: a stretch that changed no artefact is knowing
   // something, not building something, and it earns neither an artefact's nor a validation's credit.
   const kind = touched.paths.length === 0 ? "researched" : touched.committed ? "changed" : "built";
-  return {
+  const payload = {
     title: layer ? `AI-assisted work · ${layer}` : "AI-assisted work",
     kind,
     ...(layer ? { layer } : {}),
@@ -610,6 +691,9 @@ function payloadFor(stretch) {
     ...(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(),
   };
+  // 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);
+  return payload;
 }
 
 /**
@@ -901,7 +985,7 @@ const doorFor = (entry) => (String(entry?.id ?? "").startsWith("codex:") ? codex
 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 (`--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")) { const lines = historyEntries(null, true).map((entry) => JSON.stringify({ ...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 (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.
 
 if (flag("history")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "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": {
@@ -16,6 +16,7 @@
     "config-edits.mjs",
     "preserve.mjs",
     "preserve-summary.mjs",
+    "preserve-lines.mjs",
     "README.md",
     "SECURITY.md",
     "LICENSE"

package/preserve-lines.mjs

@@ -0,0 +1,73 @@
+/**
+ * WHAT AN ARCHIVE LINE MAY CARRY (split from preserve.mjs, CLI 0.7.1): the allowlist, each value checked for its type,
+ * and the behaviour signals joined on `stretch_ref`. A key not named here never reaches the archive. The capability
+ * tranches (docs/CAPABILITY-EVIDENCE-ROADMAP.md) add their fields here, each with its own check.
+ */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+const CHECK_KINDS = ["test", "typecheck", "lint", "build", "gate", "ci"], DELIVERY_KINDS = ["commit", "pr", "push", "deploy"];
+
+/** THE ALLOWLIST: what a line may carry, each value checked for its type. A key not named here never reaches the archive. */
+export 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", "interrupts", "steers"];
+export 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}$/;
+/**
+ * THE STRETCH'S BEHAVIOUR SIGNALS (0.7.0): the local counter's keys and counts per stretch, joined on `stretch_ref`,
+ * with the rubric's version. Read on this computer by count-behaviour.mjs --stretch-signals, which sends nothing; a
+ * counter that is missing, fails or answers cut leaves the archive without signals and says so, never half of them.
+ */
+export function stretchSignals(here, say) {
+  const counter = join(here, "count-behaviour.mjs");
+  if (!existsSync(counter)) return null;
+  const run = spawnSync(process.execPath, [counter, "--stretch-signals", "--months", "120"], { encoding: "utf8", maxBuffer: 1 << 29, env: { ...process.env, WORKTRUST_MCP_URL: "", WORKTRUST_MCP_TOKEN: "" } });
+  const rows = (run.stdout ?? "").split("\n").filter((text) => text.startsWith("{")).map((text) => { try { return JSON.parse(text); } catch { return null; } });
+  const end = rows.at(-1)?.stretch_signals_end;
+  if (run.status !== 0 || !Number.isInteger(end) || end !== rows.length - 1) { say("  The behaviour counter did not answer whole, so these lines carry no signals; the next run adds them to new lines."); return null; }
+  return new Map(rows.slice(0, -1).filter(Boolean).map((row) => [row.stretch_ref, row]));
+}
+const SIGNAL = /^[a-zA-Z][A-Za-z0-9._-]{1,63}$/;
+export function archiveLine(entry, behaviour = null, { ids = {}, collector } = {}) {
+  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;
+  // The computer's offset from UTC when the stretch began (0.6.18), so a working day can be read in local time.
+  if (typeof entry.utc_offset === "string" && /^[+-]\d{2}:\d{2}$/.test(entry.utc_offset)) line.utc_offset = entry.utc_offset;
+  // 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}`);
+  // VERIFICATION AND DELIVERY (0.7.1): per kind of check [ran, failed], per delivery step a count, and whether a check had
+  // passed before the first; known kinds and whole numbers only, a failure count never above its runs.
+  const whole = (value) => Number.isInteger(value) && value >= 0 && value <= 100000;
+  if (entry.verification && typeof entry.verification === "object") {
+    const kept = Object.entries(entry.verification).filter(([kind, tally]) => CHECK_KINDS.includes(kind) && Array.isArray(tally) && tally.length === 2 && tally.every(whole) && tally[1] <= tally[0] && tally[0] > 0).sort();
+    if (kept.length > 0) line.verification = Object.fromEntries(kept);
+  }
+  if (entry.delivery && typeof entry.delivery === "object") {
+    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 } : {}) };
+  }
+  // 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();
+    if (kept.length > 0) { line.signals = Object.fromEntries(kept); line.analyzer_version = behaviour.analyzer_version; }
+  }
+  return { ...line, stretch_ref: entry.stretch_ref, ...ids, collector_version: collector };
+}
+

package/preserve-summary.mjs

@@ -10,10 +10,12 @@
 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);
+  const month = (key) => months.get(key) ?? months.set(key, { seconds: 0, models: new Map(), input: 0, cached: 0, days: new Map(), delivered: 0, verifiedFirst: 0 }).get(key);
   for (const line of lines) {
     const m = month(line.day.slice(0, 7));
     m.seconds += line.seconds ?? 0;
+    // 0.7.1: stretches that delivered (a commit, a PR, a push, a deploy), and of them, those where a check passed first.
+    if (line.delivery) { m.delivered += 1; if (line.delivery.verified_first === true) m.verifiedFirst += 1; }
     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));
@@ -26,6 +28,7 @@ export function summaryLines(lines) {
     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)}%`);
+    if (m.delivered > 0) out.push(`    verified before delivery    ${m.verifiedFirst} of ${m.delivered} stretch${m.delivered === 1 ? "" : "es"} that delivered`);
     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]);

package/preserve.mjs

@@ -31,6 +31,7 @@ import { dirname, join, relative } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { summaryLines } from "./preserve-summary.mjs";
+import { archiveLine, stretchSignals } from "./preserve-lines.mjs";
 
 const args = process.argv.slice(2).filter((arg) => arg !== "preserve");
 const has = (name) => args.includes(`--${name}`);
@@ -167,12 +168,6 @@ async function apply(list, agreed = false) {
   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", "interrupts", "steers"];
-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;
@@ -187,44 +182,6 @@ function computerIds() {
   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()}`) };
 }
-/**
- * THE STRETCH'S BEHAVIOUR SIGNALS (0.7.0): the local counter's keys and counts per stretch, joined on `stretch_ref`,
- * with the rubric's version. Read on this computer by count-behaviour.mjs --stretch-signals, which sends nothing; a
- * counter that is missing, fails or answers cut leaves the archive without signals and says so, never half of them.
- */
-function stretchSignals() {
-  const counter = join(HERE, "count-behaviour.mjs");
-  if (!existsSync(counter)) return null;
-  const run = spawnSync(process.execPath, [counter, "--stretch-signals", "--months", "120"], { encoding: "utf8", maxBuffer: 1 << 29, env: { ...process.env, WORKTRUST_MCP_URL: "", WORKTRUST_MCP_TOKEN: "" } });
-  const rows = (run.stdout ?? "").split("\n").filter((text) => text.startsWith("{")).map((text) => { try { return JSON.parse(text); } catch { return null; } });
-  const end = rows.at(-1)?.stretch_signals_end;
-  if (run.status !== 0 || !Number.isInteger(end) || end !== rows.length - 1) { say("  The behaviour counter did not answer whole, so these lines carry no signals; the next run adds them to new lines."); return null; }
-  return new Map(rows.slice(0, -1).filter(Boolean).map((row) => [row.stretch_ref, row]));
-}
-const SIGNAL = /^[a-zA-Z][A-Za-z0-9._-]{1,63}$/;
-function archiveLine(entry, behaviour = null) {
-  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;
-  // The computer's offset from UTC when the stretch began (0.6.18), so a working day can be read in local time.
-  if (typeof entry.utc_offset === "string" && /^[+-]\d{2}:\d{2}$/.test(entry.utc_offset)) line.utc_offset = entry.utc_offset;
-  // 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}`);
-  // 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();
-    if (kept.length > 0) { line.signals = Object.fromEntries(kept); line.analyzer_version = behaviour.analyzer_version; }
-  }
-  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 {
@@ -302,12 +259,12 @@ function archive(dir) {
   // A WHOLE ANSWER OR NOTHING: the hook ends with its own count; one line missing or cut is a read to refuse, never part of an archive.
   const rows = hook.stdout.split("\n").filter(Boolean), end = (() => { try { return JSON.parse(rows.at(-1) ?? "").archive_end; } catch { return undefined; } })();
   if (!Number.isInteger(end) || end !== rows.length - 1) { say(`  The session hook's answer came back incomplete (${rows.length - 1} of ${end ?? "an unknown number of"} lines), so nothing was added. Run it again.`); process.exit(1); }
-  const signals = stretchSignals();
+  const signals = stretchSignals(HERE, say);
   const known = new Set(existing.lines.map((line) => line.stretch_ref)), fresh = [], measured = new Set();
   let waiting = 0;
   for (const text of rows.slice(0, -1)) {
     let entry; try { entry = JSON.parse(text); } catch { continue; }
-    const line = archiveLine(entry, signals?.get(entry.stretch_ref) ?? null);
+    const line = archiveLine(entry, signals?.get(entry.stretch_ref) ?? null, { ids: IDS, collector: COLLECTOR });
     if (line && line.day < today()) measured.add(line.stretch_ref); if (!line || known.has(line.stretch_ref)) continue; // a file present twice is one stretch
     if (line.day >= today()) { waiting += 1; continue; }
     known.add(line.stretch_ref);

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.0";
+const CLI_VERSION = "0.7.2";
 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");