worktrust 0.7.4 → 0.7.5

package/README.md

@@ -163,6 +163,7 @@ nothing it does not:
 | `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) |
 | `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) |
 | `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/package.json

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

@@ -75,6 +75,11 @@ export function archiveLine(entry, behaviour = null, { ids = {}, collector } = {
     if (entry.context.compactions > 0 || commands.length > 0) line.context = { compactions: entry.context.compactions, ...(commands.length ? { commands: Object.fromEntries(commands) } : {}) };
   }
   if (entry.routing && typeof entry.routing === "object" && whole(entry.routing.models) && whole(entry.routing.switches) && entry.routing.models > 0) line.routing = { models: entry.routing.models, switches: entry.routing.switches };
+  // STEERING (0.7.5): moments the person stepped in, how many changed the agent's course, how many led to a passing check.
+  if (entry.steering && typeof entry.steering === "object") {
+    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 };
+  }
   // 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/stretch-evidence.mjs

@@ -142,8 +142,37 @@ function routingOf(messages) {
   return models.size > 0 ? { models: models.size, switches } : null;
 }
 
+/**
+ * STEERING THAT WORKED (0.7.5; framework L4: "effective steering, not the raw number of interventions"). A moment the
+ * person stepped in while the agent was working: they stopped it, or their turn arrived right after a tool call or its
+ * result. It CHANGED COURSE when the agent's next action differed from its last one before (by kind, or by input
+ * digest), and it was EFFECTIVE when, after it, a check passed in the same stretch. Null when nobody stepped in.
+ */
+function steeringOf(messages, { isHumanTurn, INTERRUPTED, textOf }) {
+  const moments = [];
+  let lastCall = null, prev = null;
+  const passedAfter = new Map(), results = new Map();
+  for (const message of messages) for (const result of message.results ?? []) results.set(result.id, result.failed);
+  for (const message of messages) {
+    if (message.bridge) { prev = message; continue; }
+    const person = message.type === "user" && !message.meta && message.kind !== "tool_result";
+    const stopped = person && INTERRUPTED.test(textOf(message.content).trim());
+    const midTask = person && !stopped && isHumanTurn(message.content) && prev && (prev.kind === "tool_result" || prev.toolUse);
+    if (stopped || midTask) moments.push({ before: lastCall, after: null, effective: false });
+    for (const call of message.calls ?? []) {
+      for (const moment of moments) if (moment.after === null) moment.after = call;
+      if (CHECK_KINDS.some((kind) => call.kinds.includes(kind)) && results.get(call.id) === false) for (const moment of moments) if (moment.after) moment.effective = true;
+      lastCall = call;
+    }
+    prev = message;
+  }
+  if (moments.length === 0) return null;
+  const changed = moments.filter((moment) => moment.after && (!moment.before || moment.after.family !== moment.before.family || moment.after.digest !== moment.before.digest));
+  return { moments: moments.length, changed_course: changed.length, effective: changed.filter((moment) => moment.effective).length };
+}
+
 /** 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);
-  return { ...verificationOf(messages, helpers), ...(context ? { context } : {}), ...(routing ? { routing } : {}) };
+  const context = contextOf(messages, helpers), routing = routingOf(messages), steering = steeringOf(messages, helpers);
+  return { ...verificationOf(messages, helpers), ...(context ? { context } : {}), ...(routing ? { routing } : {}), ...(steering ? { steering } : {}) };
 }

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