worktrust 0.6.9 → 0.6.11

package/README.md

@@ -45,6 +45,29 @@ curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
    single `Stop` command to `~/.gemini/config/hooks.json` (kept as `hooks.json.worktrust-backup`
    first). Other hooks in that file stay as they are. Antigravity records no token counts, so its
    sessions arrive with durations and turn counts only.
+7. **Hermes Agent with the other apps.** With Hermes on this computer (`~/.hermes`, and every profile
+   under `~/.hermes/profiles`) its `config.yaml` gets the WorkTrust entry under `mcp_servers` and one
+   `on_session_end` hook that wakes the session hook; Hermes itself asks once before it runs a new
+   hook. A file that writes those sections inline is left as it is. The session hook reads Hermes's
+   own `state.db`: clocks, roles, the model and the session's token totals, never a message. A chat
+   app (Telegram, WhatsApp, Slack …) is sent as work steered from elsewhere; a subagent's, a
+   scheduled job's or a board task's session is not counted. Needs Node 22.5 or newer.
+8. **Goose, OpenCode and OpenClaw the same way.** Goose gets the entry under `extensions` in
+   `~/.config/goose/config.yaml` and one plugin folder, `~/.agents/plugins/worktrust`, whose
+   SessionEnd hook wakes the session hook. OpenCode gets it under `mcp` in
+   `~/.config/opencode/opencode.json` (a file with comments is left as it is) and one plugin file,
+   `plugin/worktrust.js`, that wakes the session hook when a session goes idle. OpenClaw is coupled
+   through its own `openclaw mcp set` (and `openclaw mcp unset` on disconnect); without that command
+   on this computer it is printed for you to run. Each is read from its own session database, the
+   same way as Hermes: clocks, roles, models and token counts, never a message. OpenClaw's Talk
+   sessions are sent as voice, its chat-app sessions as remote; subagents and scheduled runs are
+   not counted.
+9. **Cursor and GitHub Copilot in VS Code, read in place.** Cursor's chats are read from its own database
+   (`User/globalStorage/state.vscdb`), each message's type, clock, model and token counts through SQLite's own
+   `json_extract`, never the text. Copilot's are read from VS Code's `chatSessions` files: each request's two clocks
+   (asked, answered), its model and its token counts; the messages and responses are parsed with the file and never
+   kept or sent. Neither app runs a hook WorkTrust can give it, so the WorkTrust door, which both start when they
+   open, starts the session hook in the background, at most once an hour.
 
 ```
 npx worktrust history       send this computer's earlier sessions later (asks first)
@@ -77,8 +100,8 @@ which would delete every password on the computer, and many people rightly keep
 
 | | |
 |---|---|
-| **Reads** | Which AI apps are installed (the settings folders of Claude Code, Codex, Cursor, Gemini CLI, Antigravity, VS Code, Windsurf). Afterwards, the session hook reads Claude Code's, Codex's and Antigravity's own session files on this computer to measure durations and token counts. |
-| **Writes** | The key file (above). In each AI app's MCP settings (`~/.claude.json` through `claude mcp`, `~/.cursor/mcp.json`, `~/.codex/config.toml`, `~/.gemini/settings.json`, `~/.gemini/config/mcp_config.json` (Antigravity), VS Code's `mcp.json`, Windsurf's `mcp_config.json`) a WorkTrust entry that runs the local bridge, with no key in it; three hooks in `~/.claude/settings.json`; the bridge, the hook and the counter in `~/.worktrust/`. |
+| **Reads** | Which AI apps are installed (the settings folders of Claude Code, Codex, Cursor, Gemini CLI, Antigravity, VS Code, Windsurf, Hermes Agent, Goose, OpenCode, OpenClaw), and the chats Cursor and Copilot keep (clocks, models and token counts only). Afterwards, the session hook reads Claude Code's, Codex's and Antigravity's session files and the session databases of Hermes, Goose, OpenCode and OpenClaw on this computer to measure durations and token counts. |
+| **Writes** | The key file (above). In each AI app's MCP settings (`~/.claude.json` through `claude mcp`, `~/.cursor/mcp.json`, `~/.codex/config.toml`, `~/.gemini/settings.json`, `~/.gemini/config/mcp_config.json` (Antigravity), VS Code's `mcp.json`, Windsurf's `mcp_config.json`, Hermes's and Goose's `config.yaml`, OpenCode's `opencode.json`, OpenClaw through `openclaw mcp set`) a WorkTrust entry that runs the local bridge, with no key in it; three hooks in `~/.claude/settings.json`; the bridge, the hook and the counter in `~/.worktrust/`. |
 | **Sends, to pair** | This computer's system (macOS, Windows, Linux) and host name. WorkTrust also records the network address the request arrives from, as a security record kept 90 days and seen only by WorkTrust staff (to answer a theft or fraud report). |
 | **Sends, afterwards** | Durations, token counts, model names, one layer keyword (frontend, backend …), counts of how you work. |
 | **Never sends** | Prompts, answers, code, file names or paths, commit messages, branch or project names. The door has no field for them and refuses a submission that carries them. |
@@ -115,7 +138,7 @@ which would delete every password on the computer, and many people rightly keep
 
 ## Undo
 
-`npx worktrust disconnect` removes the WorkTrust entries, the hook (and Codex's `notify` line and
+`npx worktrust disconnect` removes the WorkTrust entries (Hermes's hook with them), the hook (and Codex's `notify` line and
 Antigravity's `worktrust` hook when WorkTrust set them) and the key file, and empties
 `~/.worktrust` but for one small note of which account it fed (masked), so that a later coupling by
 another account offers none of this computer's earlier work.

package/config-edits.mjs

@@ -0,0 +1,69 @@
+/**
+ * CONFIG EDITS — a YAML file edited line by line, never re-serialised (2026-10-05).
+ *
+ * Hermes Agent and Goose keep their settings in YAML, written by people, with comments and their own indentation.
+ * setup-mcp.mjs puts WorkTrust's entry into them and takes it out again with these: a section is found by its key at
+ * a known indent, an entry is added at the indent its siblings use, and a removal leaves every other byte as it was.
+ * Only block style is handled; a section written inline (`key: { … }`) makes placeUnder return false, and the caller
+ * leaves the file alone. No dependency: it ships beside setup-mcp.mjs.
+ */
+const indentOf = (line) => line.length - line.trimStart().length;
+const meaningful = (line) => line.trim() !== "" && !line.trimStart().startsWith("#");
+/** `key:` at `indent` between start and stop: its line and the end of its block, or the inline value it carries. */
+function section(lines, start, stop, indent, key) {
+  for (let i = start; i < stop; i += 1) {
+    if (!meaningful(lines[i]) || indentOf(lines[i]) !== indent) continue;
+    const match = new RegExp(`^\\s*${key}:(?:\\s+(.*?))?\\s*$`).exec(lines[i]);
+    if (!match) continue;
+    const inline = match[1] && !match[1].startsWith("#") ? match[1] : null;
+    let end = i + 1;
+    while (end < stop && (!meaningful(lines[end]) || indentOf(lines[end]) > indent || (indentOf(lines[end]) === indent && lines[end].trimStart().startsWith("-")))) end += 1;
+    while (end > i + 1 && !meaningful(lines[end - 1])) end -= 1;
+    return { at: i, end, inline };
+  }
+  return null;
+}
+/** The entries of a block (a mapping's keys or a list's items), each [from, to). */
+function entries(lines, at, end) {
+  const starts = [];
+  const first = lines.slice(at + 1, end).find(meaningful);
+  const child = first === undefined ? null : indentOf(first);
+  for (let i = at + 1; i < end; i += 1) if (meaningful(lines[i]) && indentOf(lines[i]) === child) starts.push(i);
+  return { child, ranges: starts.map((from, n) => [from, starts[n + 1] ?? end]) };
+}
+const EMPTY_INLINE = new Set(["{}", "[]", "null", "~"]);
+/** Puts `unit` under the path, making each section that is missing; false when one is written inline. */
+export function placeUnder(lines, path, unit) {
+  let start = 0, stop = lines.length, indent = 0;
+  for (const [n, key] of path.entries()) {
+    let found = section(lines, start, stop, indent, key);
+    if (found?.inline && !EMPTY_INLINE.has(found.inline)) return false;
+    if (found?.inline) lines[found.at] = `${" ".repeat(indent)}${key}:`;
+    if (!found) { lines.splice(stop, 0, `${" ".repeat(indent)}${key}:`); found = { at: stop, end: stop + 1 }; }
+    const child = entries(lines, found.at, found.end).child ?? indent + 2;
+    if (n === path.length - 1) { lines.splice(found.end, 0, ...unit.map((line) => " ".repeat(child) + line)); return true; }
+    start = found.at + 1; stop = found.end; indent = child;
+  }
+  return true;
+}
+/** The section at the end of a path, in block style; null when absent or inline. */
+function find(lines, path) {
+  let start = 0, stop = lines.length, indent = 0, found = null;
+  for (const key of path) {
+    found = section(lines, start, stop, indent, key);
+    if (!found || found.inline) return null;
+    start = found.at + 1; stop = found.end; indent = entries(lines, found.at, found.end).child ?? indent + 2;
+  }
+  return found;
+}
+/** Takes out every entry under the path that is ours, and a section that leaves empty. */
+export function takeOut(lines, path, mine) {
+  const found = find(lines, path);
+  if (!found) return;
+  let removed = 0;
+  for (const [from, to] of entries(lines, found.at, found.end).ranges.reverse()) if (mine(lines.slice(from, to).join("\n"))) { lines.splice(from, to - from); removed += 1; }
+  if (removed > 0) for (let depth = path.length; depth > 0; depth -= 1) {
+    const left = find(lines, path.slice(0, depth));
+    if (left && !lines.slice(left.at + 1, left.end).some(meaningful)) lines.splice(left.at, left.end - left.at);
+  }
+}

package/log-session.mjs

@@ -196,24 +196,26 @@ const excludes = (() => {
 })();
 const excluded = (path) => excludes.some((text) => text && path.includes(text));
 /**
- * THE READERS FOR CODEX AND ANTIGRAVITY live in transcript-readers.mjs beside this file (2026-10-04;
- * the counter imports the same file, so there is one reader, not two copies). The install copies it
- * into ~/.worktrust with this hook. Without it this hook still reads Claude Code; the never-matching
- * patterns below keep every other client out rather than half read.
+ * THE READERS live beside this file: Codex and Antigravity in transcript-readers.mjs (the counter imports it too, one
+ * reader), the database clients in session-databases.mjs. The install copies both into ~/.worktrust with this hook.
+ * Without them this hook still reads Claude Code; the never-matching patterns keep every other client out.
  */
 const { CODEX_ROLLOUT = /(?!)/, codexLines, codexRolloutFiles = function* () {}, codexCwd = () => null, ANTIGRAVITY_TRANSCRIPT = /(?!)/, antigravityLines, antigravityRoots = () => [], antigravityTranscripts = function* () {}, antigravityContext = () => ({}), rememberAntigravity = () => null } = (await import("./transcript-readers.mjs").catch(() => null)) ?? {};
-const READERS = join(dirname(fileURLToPath(import.meta.url)), "transcript-readers.mjs");
-const READERS_HOME = join(homedir(), ".worktrust", "transcript-readers.mjs");
+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 READER_FILES = ["transcript-readers.mjs", "session-databases.mjs"];
 /** The readers go where the hook and the counter run: copied from beside this file, else (or for a newer counter) from the deployment. */
 async function installReaders(origin, fromNetwork = false) {
-  try {
-    if (!fromNetwork && existsSync(READERS)) { mkdirSync(dirname(READERS_HOME), { recursive: true }); if (READERS !== READERS_HOME) copyFileSync(READERS, READERS_HOME); return true; }
-    if (!origin) return false;
-    const response = await fetch(`${origin}/counter/transcript-readers.mjs`);
-    if (!response.ok) return false;
-    writeFileSync(READERS_HOME, await response.text());
-    return true;
-  } catch { return false; }
+  let installed = true;
+  for (const name of READER_FILES) { // Hermes, Goose, OpenCode and OpenClaw are read by session-databases.mjs
+    const here = join(dirname(fileURLToPath(import.meta.url)), name), home = join(homedir(), ".worktrust", name);
+    try {
+      if (!fromNetwork && existsSync(here)) { mkdirSync(dirname(home), { recursive: true }); if (here !== home) copyFileSync(here, home); continue; }
+      const response = origin ? await fetch(`${origin}/counter/${name}`) : null;
+      if (response?.ok) writeFileSync(home, await response.text()); else installed = false;
+    } catch { installed = false; }
+  }
+  return installed;
 }
 
 /** The roots this machine's transcripts live under; a test names its own. */
@@ -228,6 +230,14 @@ function* codexRollouts() {
     yield { id: `codex:${file.split("/").at(-1).replace(/\.jsonl$/, "")}`, file };
   }
   yield* antigravityConversations();
+  yield* databaseConversations();
+}
+/** The attended sessions of the clients that keep a database (session-databases.mjs); an excluded folder skipped. */
+function* databaseConversations() {
+  const given = Object.fromEntries(DATABASE_CLIENTS.map((client) => [client, value(`${client}-root`)]).filter(([, root]) => root));
+  for (const { client, sessionId, file, cwd, writtenAt } of databaseSessions(given, Boolean(value("transcript-root")))) {
+    if (!(cwd && excluded(cwd))) yield { id: `${client}:${sessionId}`, file, writtenAt };
+  }
 }
 /** Antigravity beside Codex: one transcript per conversation, its folder known only from the Stop hook. */
 function* antigravityConversations() {
@@ -239,6 +249,7 @@ function* antigravityConversations() {
 }
 /** A transcript's lines as objects, whichever client wrote it; null when the file cannot be read. */
 const parsedLines = (file) => {
+  if (DATABASE_SESSION.test(file)) return databaseLines(file);
   let lines; try { lines = readFileSync(file, "utf8").split("\n"); } catch { return null; }
   if (CODEX_ROLLOUT.test(file)) return [...codexLines(lines)];
   if (ANTIGRAVITY_TRANSCRIPT.test(file)) { const id = file.split("/").at(-4); return [...antigravityLines(lines, { id, ...antigravityContext(id) })]; }
@@ -313,9 +324,10 @@ function stretchesOf(file, since) {
   const lines = parsedLines(file);
   if (!lines) return [];
   const messages = [];
-  let cwd = null;
+  let cwd = null, steered = STEERED_HERE;
   for (const line of lines) {
     if (typeof line.cwd === "string") cwd = line.cwd;
+    if (typeof line.steered === "string") steered = line.steered; // a client that says how it was steered (Hermes's source)
     if (!line.timestamp || (line.type !== "user" && line.type !== "assistant")) continue;
     const at = Date.parse(line.timestamp);
     if (!Number.isFinite(at)) continue;
@@ -330,7 +342,7 @@ function stretchesOf(file, since) {
     if (!byDay.has(day)) byDay.set(day, []);
     byDay.get(day).push(message);
   }
-  return [...byDay.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([, ofDay]) => measure(cwd, ofDay)).filter(Boolean);
+  return [...byDay.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([day, ofDay]) => { const stretch = measure(cwd, ofDay); return stretch && { ...stretch, ref: stretchRef(file, day), steered }; }).filter(Boolean);
 }
 
 /**
@@ -408,6 +420,11 @@ function tokensOf(messages) {
   return { tokensIn, tokensOut, cacheRead, cacheWrite, shapeKnown: counted > 0 };
 }
 
+// WHICH STRETCH, HOW STEERED (0.6.10): a hash of the session id (the file name) and the day, the same on any computer, so a
+// restored backup is never counted twice; `remote` only when the session runs over SSH, otherwise nothing is said.
+const stretchRef = (file, day) => createHash("sha256").update(`worktrust-stretch|${String(file).split(/[\\/]/).pop().replace(/\.jsonl?$/, "")}|${day}`).digest("base64url");
+const STEERED_HERE = process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY ? "remote" : null;
+
 /** The one payload shape this script can build. Every key is a number, a date or an enum value. */
 function payloadFor(stretch) {
   const cwd = stretch.cwd && existsSync(stretch.cwd) ? stretch.cwd : null;
@@ -437,6 +454,7 @@ function payloadFor(stretch) {
     ...(stretch.model ? { model: stretch.model } : {}),
     ...(repo ? { repo } : {}),
     ...(touched.shas.length > 0 ? { commits: touched.shas.slice(0, 50) } : {}),
+    ...(stretch.ref ? { stretch_ref: stretch.ref } : {}), ...(stretch.steered ? { steered_from: stretch.steered } : {}),
     at: new Date(stretch.to).toISOString(),
   };
 }
@@ -453,7 +471,7 @@ async function sendHistory(door, entries, announce = false) {
   // A Codex entry goes through Codex's own coupling where one exists (see codexDoor), the rest
   // through the door given: the record files a line under the coupling that sent it. Antigravity's
   // go apart too, so their batch can name the client (clientOf).
-  for (const [source, group] of [["claude", entries.filter((entry) => !entrySource.has(entry))], ["codex", entries.filter((entry) => entrySource.get(entry) === "codex")], ["antigravity", entries.filter((entry) => entrySource.get(entry) === "antigravity")]]) {
+  for (const [source, group] of [["claude", entries.filter((entry) => !entrySource.has(entry))], ["codex", entries.filter((entry) => entrySource.get(entry) === "codex")], ...["antigravity", ...DATABASE_CLIENTS].map((client) => [client, entries.filter((entry) => entrySource.get(entry) === client)])]) {
   const target = source === "codex" ? codexDoor ?? door : door;
   if (group.length === 0 || !target) continue;
   for (let i = 0; i < group.length; i += 200) {
@@ -484,7 +502,7 @@ const proofFor = (url, body) => {
  * on this computer, and the door names a coupling's clients by the user-agent it hears (mcp_identify's
  * agents_seen). An Antigravity line names Antigravity: the product name, nothing of the work.
  */
-const clientOf = (source) => (source === "antigravity" ? { "user-agent": "antigravity/hook (worktrust-hook)" } : {});
+const clientOf = (source) => (source === "antigravity" || DATABASE_CLIENTS.includes(source) ? { "user-agent": `${source}/hook (worktrust-hook)` } : {});
 
 async function send(door, payload) {
   const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "log_work", arguments: payload } });
@@ -512,10 +530,11 @@ function historyEntries(floor = null) {
   for (const { file } of allTranscripts()) {
     const lines = parsedLines(file);
     if (!lines) continue;
-    let cwd = null;
+    let cwd = null, steered = null;
     const byDay = new Map();
     for (const line of lines) {
       if (typeof line.cwd === "string") cwd = line.cwd;
+      if (typeof line.steered === "string") steered = line.steered;
       if (!line.timestamp || (line.type !== "user" && line.type !== "assistant")) continue;
       const at = Date.parse(line.timestamp);
       if (!Number.isFinite(at)) continue;
@@ -543,13 +562,13 @@ function historyEntries(floor = null) {
       const entry = payloadFor({
         cwd, seconds: seconds >= MIN_SECONDS ? Math.min(MAX_SECONDS, seconds) : null,
         tokensIn, tokensOut, cacheRead, cacheWrite, shapeKnown, exchanges, model: [...models.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null,
-        from: messages[0].at, to: last,
+        from: messages[0].at, to: last, ref: stretchRef(file, day), steered,
       });
       if (CODEX_ROLLOUT.test(file)) entrySource.set(entry, "codex");
       if (ANTIGRAVITY_TRANSCRIPT.test(file)) entrySource.set(entry, "antigravity");
+      if (DATABASE_SESSION.test(file)) entrySource.set(entry, file.slice(0, file.indexOf(":")));
       entryFile.set(entry, file);
       entries.push(entry);
-      void day;
     }
   }
   return entries.sort((a, b) => a.at.localeCompare(b.at));
@@ -581,6 +600,7 @@ function* allTranscripts() {
  */
 function* candidates() {
   for (const rollout of codexRollouts()) {
+    if (rollout.writtenAt) { yield rollout; continue; } // a database session knows its own last moment
     let stat; try { stat = statSync(rollout.file); } catch { continue; }
     yield { ...rollout, writtenAt: stat.mtimeMs };
   }
@@ -630,7 +650,7 @@ if (flag("uninstall")) {
   }
   const removed = before !== JSON.stringify(HOOK_EVENTS.map((event) => settings.hooks?.[event] ?? []));
   if (removed) writeFileSync(file, JSON.stringify(settings, null, 2));
-  if (flag("purge")) for (const path of [COUNTER, PINNED, join(homedir(), ".worktrust", "log-session.mjs"), STATE, READERS_HOME, join(homedir(), ".worktrust", "antigravity.json")]) { try { rmSync(path); } catch { /* already gone */ } }
+  if (flag("purge")) for (const path of [COUNTER, PINNED, join(homedir(), ".worktrust", "log-session.mjs"), STATE, ...READER_FILES.map((name) => join(homedir(), ".worktrust", name)), join(homedir(), ".worktrust", "antigravity.json")]) { try { rmSync(path); } catch { /* already gone */ } }
   console.log(`${removed ? "removed" : "nothing wired"}: ${file}${flag("purge") ? "\n         purged ~/.worktrust" : ""}`);
   console.log("the coupling itself still exists: end it in the app (Sources → the computer's row → end this coupling)");
   process.exit(0);
@@ -698,7 +718,7 @@ if (flag("install")) {
   // The counting half, from the same deployment the hook came from: one command installs both, or
   // says plainly that it could not — a half nobody knows is missing is the worse outcome.
   const counterOrigin = coupling()?.url ? new URL(coupling().url).origin : null;
-  if (!(await installReaders(counterOrigin))) console.log("readers:   transcript-readers.mjs not found beside this file nor at the deployment; Codex and Antigravity are not read until it is");
+  if (!(await installReaders(counterOrigin))) console.log("readers:   transcript-readers.mjs or session-databases.mjs not found beside this file nor at the deployment; the clients they read are not read until they are");
   if (existsSync(COUNTER)) await refreshCounter(counterOrigin, (line) => console.log(line));
   if (!existsSync(COUNTER)) {
     const origin = counterOrigin;
@@ -802,7 +822,7 @@ for (const entry of work) {
     // every day but today, on whichever run comes first — it no longer waits for its own end.
     if (Date.now() - stretch.to < IDLE_BEFORE_SWEEP) break;
     const payload = payloadFor(stretch);
-    const source = /^(codex|antigravity):/.exec(String(entry.id))?.[1];
+    const source = /^(codex|antigravity|hermes|goose|opencode|openclaw):/.exec(String(entry.id))?.[1];
     if (source) entrySource.set(payload, source);
     if (DRY) { console.log(JSON.stringify({ ...payload, client: source ?? "claude", route: Date.now() - stretch.to > WINDOW_HOURS * 3600_000 ? "history" : "log_work" }, null, 1)); through = stretch.to; continue; }
     // MEASURED TIME IS NEVER DROPPED. The live door takes work as it happens and refuses anything

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "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": {
@@ -12,6 +12,8 @@
     "log-session.mjs",
     "count-behaviour.mjs",
     "transcript-readers.mjs",
+    "session-databases.mjs",
+    "config-edits.mjs",
     "README.md",
     "SECURITY.md",
     "LICENSE"

package/session-databases.mjs

@@ -0,0 +1,448 @@
+/**
+ * THE SESSION DATABASES — the clients that keep their sessions in SQLite, read into Claude Code's shape (2026-10-05).
+ *
+ * Hermes Agent, Goose, OpenCode and OpenClaw keep no transcript file: each writes its sessions to its own SQLite
+ * database. This reads them through node:sqlite (Node 22.5+), read-only, into the same lines transcript-readers.mjs
+ * makes of the files, so the session hook's one clock reads them all. Each query takes roles, clocks, models and token
+ * counts and no text column (scripts/test-database-clients.mjs holds every query to that). It ships beside the hook,
+ * like transcript-readers.mjs; without it, or without node:sqlite, these clients are not read and nothing else changes.
+ */
+import { createRequire } from "node:module";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import * as zlib from "node:zlib"; // zstd since Node 22.15; older Node reads OpenClaw's uncompressed rows only
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { cleanModel } from "./transcript-readers.mjs";
+
+// ── hermes session reader ──
+/**
+ * HERMES AGENT, READ FROM ITS OWN DATABASE (Nous Research, 2026-10-05). Hermes keeps every session in one SQLite file
+ * per profile: `state.db` under its home (~/.hermes, %LOCALAPPDATA%/hermes on Windows, HERMES_HOME when set) and under
+ * each profile in profiles/<name>/ (hermes-agent.nousresearch.com/docs/developer-guide/session-storage, /user-guide/profiles).
+ * A session is read as a transcript: each message's role and clock, never its `content`, which this query does not
+ * select. A user message is a human turn, a tool message the loop's own result. The session's token totals ride on its
+ * last assistant message (Hermes keeps them per session, not per response). `source` says how it was steered: the
+ * terminal or the desktop app is the desk, a chat app (Telegram, WhatsApp, Slack …) is the computer driven from
+ * elsewhere. A subagent's, a scheduled job's or a board task's session has no person at the controls and its time
+ * already lies inside its parent's: it is not read. Needs node:sqlite (Node 22.5+); without it Hermes is not read.
+ */
+const HERMES_DESK = new Set(["cli", "desktop", "dashboard", "tui"]);
+const HERMES_REMOTE = new Set(["telegram", "discord", "slack", "whatsapp", "signal", "matrix", "mattermost", "email", "sms", "homeassistant", "feishu", "dingtalk", "wecom", "weixin", "bluebubbles", "qqbot"]);
+const HERMES_UNATTENDED = new Set(["subagent", "cron", "kanban"]);
+export const hermesSteered = (source) => (HERMES_DESK.has(source) ? "desk" : HERMES_REMOTE.has(source) ? "remote" : null);
+let sqlite;
+/** A database session's pseudo-file, `<client>:<database>#<session id>`, back into its parts. */
+const splitSession = (pseudo) => { const at = pseudo.lastIndexOf("#"); return { file: pseudo.slice(pseudo.indexOf(":") + 1, at), id: pseudo.slice(at + 1) }; };
+const openDatabase = (file) => {
+  if (sqlite === undefined) {
+    // node:sqlite says it is experimental on some Node versions; that line is not the person's business inside a hook.
+    const warn = process.emitWarning;
+    try { process.emitWarning = () => {}; sqlite = createRequire(import.meta.url)("node:sqlite"); } catch { sqlite = null; } finally { process.emitWarning = warn; }
+  }
+  if (!sqlite) return null;
+  try { return new sqlite.DatabaseSync(file, { readOnly: true }); } catch { return null; }
+};
+/** Hermes's homes on this machine: the default, HERMES_HOME, and every profile's. A test names its own. */
+export function hermesHomes(given) {
+  if (given) return [given.replace(/^~(?=\/|$)/, homedir())];
+  const base = platform() === "win32" && process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "hermes") : join(homedir(), ".hermes");
+  const homes = new Set([base, ...(process.env.HERMES_HOME ? [process.env.HERMES_HOME] : [])]);
+  try { for (const name of readdirSync(join(base, "profiles")).sort()) homes.add(join(base, "profiles", name)); } catch { /* no profiles */ }
+  return [...homes];
+}
+export const hermesHere = () => hermesHomes().some((home) => { try { return statSync(join(home, "config.yaml")).isFile() || statSync(join(home, "state.db")).isFile(); } catch { return false; } });
+const columnsOf = (db, table) => new Set(db.prepare(`pragma table_info(${table})`).all().map((row) => row.name));
+/** Every attended session under the homes: its id, its pseudo-file, its folder and its last message's moment. */
+export function* hermesSessions(homes) {
+  for (const home of homes) {
+    const file = join(home, "state.db");
+    try { if (!statSync(file).isFile()) continue; } catch { continue; }
+    const db = openDatabase(file);
+    if (!db) continue;
+    try {
+      const has = columnsOf(db, "sessions");
+      const rows = db.prepare(`select s.id, s.source, s.parent_session_id as parent, ${has.has("cwd") ? "s.cwd" : "null"} as cwd, max(m.timestamp) as last
+        from sessions s join messages m on m.session_id = s.id group by s.id order by s.id`).all();
+      for (const row of rows) {
+        if (row.parent || HERMES_UNATTENDED.has(row.source) || !/^[A-Za-z0-9_.:-]{1,120}$/.test(String(row.id))) continue;
+        yield { sessionId: String(row.id), file: `hermes:${file}#${row.id}`, cwd: typeof row.cwd === "string" ? row.cwd : null, writtenAt: Number(row.last) * 1000 };
+      }
+    } catch { /* an older or foreign schema: not read */ } finally { db.close(); }
+  }
+}
+/** One session → lines in Claude Code's shape: roles, clocks, the model, the totals, the folder and the steering. No text. */
+export function hermesLines(pseudo) {
+  const { file, id } = splitSession(pseudo);
+  const db = openDatabase(file);
+  if (!db) return null;
+  try {
+    const has = columnsOf(db, "sessions");
+    const pick = (name) => (has.has(name) ? `${name}` : `0 as ${name}`);
+    const session = db.prepare(`select source, model, ${has.has("cwd") ? "cwd" : "null as cwd"}, ${["input_tokens", "output_tokens", "cache_read_tokens", "cache_write_tokens"].map(pick).join(", ")} from sessions where id = ?`).get(id);
+    if (!session) return [];
+    const messages = db.prepare("select role, timestamp from messages where session_id = ? and timestamp is not null order by timestamp, id").all(id);
+    const model = cleanModel(session.model);
+    const out = [{ type: "meta", ...(typeof session.cwd === "string" ? { cwd: session.cwd } : {}), steered: hermesSteered(session.source) }];
+    const lastAssistant = messages.map((m) => m.role).lastIndexOf("assistant");
+    messages.forEach((message, i) => {
+      const timestamp = new Date(Number(message.timestamp) * 1000).toISOString();
+      if (message.role === "user") out.push({ type: "user", timestamp, message: { content: [{ type: "text" }] } });
+      else if (message.role === "tool") out.push({ type: "user", timestamp, message: { content: [{ type: "tool_result" }] } });
+      else if (message.role === "assistant") out.push({ type: "assistant", timestamp, message: { model, ...(i === lastAssistant ? { usage: { input_tokens: Number(session.input_tokens) || 0, output_tokens: Number(session.output_tokens) || 0, cache_read_input_tokens: Number(session.cache_read_tokens) || 0, cache_creation_input_tokens: Number(session.cache_write_tokens) || 0 } } : {}), content: [] } });
+    });
+    return out;
+  } catch { return null; } finally { db.close(); }
+}
+// ── end hermes session reader ──
+
+// ── goose session reader ──
+/**
+ * GOOSE, READ FROM ITS OWN DATABASE (2026-10-05). Goose (aaif-goose/goose, formerly block/goose) keeps every session in
+ * one SQLite file since 1.10, `sessions/sessions.db` under its data folder (~/.local/share/goose, %APPDATA%\\Block\\goose\\data
+ * on Windows, <GOOSE_PATH_ROOT>/data when set; crates/goose/src/session/session_manager.rs, config/paths.rs). A session
+ * is read as a transcript: each message's role, its clock (`created_timestamp`, seconds) and the TYPE of each content
+ * block, read inside SQLite with json_extract so the text never leaves the database: a user message that answers a tool
+ * (`toolResponse`) is the loop, one with text or an image is the person. Tokens come from the per-call `usage_ledger`
+ * rows (model per call), each on the assistant message at or before it; without that table, the session's accumulated
+ * totals ride on its last assistant message. A subagent's, a scheduled run's or a hidden session is not read; a session
+ * through the gateway (a chat app) is steered from elsewhere, any other from the desk.
+ */
+const GOOSE_UNATTENDED = new Set(["sub_agent", "scheduled", "hidden"]);
+export const gooseSteered = (type) => (type === "gateway" ? "remote" : type ? "desk" : null);
+export function gooseHomes(given) {
+  if (given) return [given.replace(/^~(?=\/|$)/, homedir())];
+  const homes = [join(homedir(), ".local", "share", "goose"), join(homedir(), "Library", "Application Support", "Block", "goose")];
+  if (process.env.GOOSE_PATH_ROOT) homes.unshift(join(process.env.GOOSE_PATH_ROOT, "data"));
+  if (platform() === "win32" && process.env.APPDATA) homes.push(join(process.env.APPDATA, "Block", "goose", "data"));
+  return homes;
+}
+export function* gooseSessions(homes) {
+  for (const home of homes) {
+    const file = join(home, "sessions", "sessions.db");
+    try { if (!statSync(file).isFile()) continue; } catch { continue; }
+    const db = openDatabase(file);
+    if (!db) continue;
+    try {
+      const rows = db.prepare(`select s.id, s.session_type as type, s.parent_session_id as parent, s.working_dir as cwd, max(m.created_timestamp) as last
+        from sessions s join messages m on m.session_id = s.id group by s.id order by s.id`).all();
+      for (const row of rows) {
+        if (row.parent || GOOSE_UNATTENDED.has(row.type) || !/^[A-Za-z0-9_.:-]{1,120}$/.test(String(row.id))) continue;
+        const last = Number(row.last);
+        yield { sessionId: String(row.id), file: `goose:${file}#${row.id}`, cwd: typeof row.cwd === "string" ? row.cwd : null, writtenAt: (last > 1e10 ? last : last * 1000) };
+      }
+    } catch { /* an older or foreign schema: not read */ } finally { db.close(); }
+  }
+}
+export function gooseLines(pseudo) {
+  const { file, id } = splitSession(pseudo);
+  const db = openDatabase(file);
+  if (!db) return null;
+  const ms = (value) => { const n = Number(value); return n > 1e10 ? n : n * 1000; };
+  try {
+    const session = db.prepare(`select session_type as type, working_dir as cwd, json_extract(model_config_json, '$.model_name') as model,
+      accumulated_input_tokens as input, accumulated_output_tokens as output, accumulated_cache_read_tokens as cache_read, accumulated_cache_write_tokens as cache_write
+      from sessions where id = ?`).get(id);
+    if (!session) return [];
+    const messages = db.prepare(`select role, created_timestamp as at,
+      case when json_valid(content_json) then (select group_concat(json_extract(value, '$.type')) from json_each(content_json)) end as kinds
+      from messages where session_id = ? order by created_timestamp, id`).all(id);
+    const ledger = db.prepare("select 1 from sqlite_master where type = 'table' and name = 'usage_ledger'").get()
+      ? db.prepare("select created_timestamp as at, model, input_tokens as input, output_tokens as output, cache_read_tokens as cache_read, cache_write_tokens as cache_write from usage_ledger where session_id = ? order by created_timestamp, id").all(id)
+      : null;
+    const fallbackModel = cleanModel(session.model);
+    const lines = messages.map((message) => {
+      const kinds = new Set(String(message.kinds ?? "").split(","));
+      const timestamp = new Date(ms(message.at)).toISOString();
+      if (message.role === "user") return { type: "user", timestamp, message: { content: [{ type: kinds.has("toolResponse") ? "tool_result" : kinds.has("text") || kinds.has("image") ? "text" : "tool_result" }] } };
+      return { type: "assistant", timestamp, at: ms(message.at), message: { model: fallbackModel, content: [] } };
+    });
+    const assistants = lines.filter((line) => line.type === "assistant");
+    const usageOf = (row) => ({ input_tokens: Number(row.input) || 0, output_tokens: Number(row.output) || 0, cache_read_input_tokens: Number(row.cache_read) || 0, cache_creation_input_tokens: Number(row.cache_write) || 0 });
+    const add = (line, usage) => { const was = line.message.usage; line.message.usage = was ? Object.fromEntries(Object.entries(usage).map(([key, n]) => [key, n + (was[key] ?? 0)])) : usage; };
+    if (ledger) for (const row of ledger) {
+      const at = ms(row.at) + 1000;
+      const line = [...assistants].reverse().find((one) => one.at <= at) ?? assistants[0];
+      if (!line) continue;
+      add(line, usageOf(row));
+      if (cleanModel(row.model)) line.message.model = cleanModel(row.model);
+    } else if (assistants.length) add(assistants.at(-1), usageOf(session));
+    for (const line of assistants) delete line.at;
+    return [{ type: "meta", ...(typeof session.cwd === "string" ? { cwd: session.cwd } : {}), steered: gooseSteered(session.type) }, ...lines];
+  } catch { return null; } finally { db.close(); }
+}
+// ── end goose session reader ──
+
+// ── opencode session reader ──
+/**
+ * OPENCODE, READ FROM ITS OWN DATABASE (2026-10-05). OpenCode (anomalyco/opencode, formerly sst/opencode) keeps its
+ * sessions in SQLite, `opencode.db` (or `opencode-<channel>.db`) under ~/.local/share/opencode on every system
+ * (packages/core/src/database/database.ts, session/sql.ts). A message's `data` is JSON; only its role, its clock
+ * (`time.created`, ms), its model and its token counts are taken out, inside SQLite with json_extract, so no text
+ * leaves the database (text lives in the `part` table, which is never read). A subagent's session (`parent_id`) is not
+ * read. How it was steered is not said: the terminal, the desktop app and a phone on `opencode serve` look alike here.
+ */
+export function opencodeHomes(given) {
+  if (given) return [given.replace(/^~(?=\/|$)/, homedir())];
+  return [join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "opencode")];
+}
+const opencodeDatabases = (home) => { try { return readdirSync(home).filter((name) => /^opencode(-[A-Za-z0-9_.-]+)?\.db$/.test(name)).sort().map((name) => join(home, name)); } catch { return []; } };
+export function* opencodeSessions(homes) {
+  for (const home of homes) for (const file of opencodeDatabases(home)) {
+    const db = openDatabase(file);
+    if (!db) continue;
+    try {
+      const rows = db.prepare(`select s.id, s.parent_id as parent, s.directory as cwd, max(m.time_created) as last
+        from session s join message m on m.session_id = s.id group by s.id order by s.id`).all();
+      for (const row of rows) {
+        if (row.parent || !/^[A-Za-z0-9_.:-]{1,120}$/.test(String(row.id))) continue;
+        yield { sessionId: String(row.id), file: `opencode:${file}#${row.id}`, cwd: typeof row.cwd === "string" ? row.cwd : null, writtenAt: Number(row.last) };
+      }
+    } catch { /* an older or foreign schema: not read */ } finally { db.close(); }
+  }
+}
+export function opencodeLines(pseudo) {
+  const { file, id } = splitSession(pseudo);
+  const db = openDatabase(file);
+  if (!db) return null;
+  try {
+    const session = db.prepare("select directory as cwd from session where id = ?").get(id);
+    if (!session) return [];
+    const messages = db.prepare(`select json_extract(data, '$.role') as role, coalesce(json_extract(data, '$.time.created'), time_created) as at,
+      json_extract(data, '$.modelID') as model, json_extract(data, '$.tokens.input') as input, json_extract(data, '$.tokens.output') as output,
+      json_extract(data, '$.tokens.reasoning') as reasoning, json_extract(data, '$.tokens.cache.read') as cache_read, json_extract(data, '$.tokens.cache.write') as cache_write
+      from message where session_id = ? order by time_created, id`).all(id);
+    const lines = messages.map((message) => {
+      const timestamp = new Date(Number(message.at)).toISOString();
+      if (message.role === "user") return { type: "user", timestamp, message: { content: [{ type: "text" }] } };
+      const counted = message.input !== null || message.output !== null;
+      return { type: "assistant", timestamp, message: { model: cleanModel(message.model), ...(counted ? { usage: { input_tokens: Number(message.input) || 0, output_tokens: (Number(message.output) || 0) + (Number(message.reasoning) || 0), cache_read_input_tokens: Number(message.cache_read) || 0, cache_creation_input_tokens: Number(message.cache_write) || 0 } } : {}), content: [] } };
+    });
+    return [{ type: "meta", ...(typeof session.cwd === "string" ? { cwd: session.cwd } : {}) }, ...lines];
+  } catch { return null; } finally { db.close(); }
+}
+// ── end opencode session reader ──
+
+// ── openclaw session reader ──
+/**
+ * OPENCLAW, READ FROM ITS OWN DATABASE (2026-10-05). OpenClaw keeps each agent's sessions in SQLite,
+ * ~/.openclaw/agents/<agentId>/agent/openclaw-agent.sqlite (OPENCLAW_STATE_DIR moves ~/.openclaw;
+ * src/state/openclaw-agent-schema.sql). A window (`session_windows`) is one session; its transcript is
+ * `transcript_events`, one JSON event per row, or the same JSON zstd-compressed when large. From a `message` event only
+ * the role, the clock (ms), the model and the usage are taken: in SQLite with json_extract for the plain rows, and in
+ * memory for a compressed row, whose text is dropped as soon as those four are read. A spawned, scheduled, plugin or
+ * internal session is not read. Steering: a Talk session (`created_via = 'talk'`) is voice; one that came through a
+ * chat channel (WhatsApp, Telegram, Slack …) is remote; the rest is not said.
+ */
+const OPENCLAW_UNATTENDED = new Set(["spawn", "cron", "plugin", "internal"]);
+const OPENCLAW_LOCAL = new Set(["webchat", "cli", "tui", "terminal", "desktop", "macos", "control-ui"]);
+export const openclawSteered = (createdVia, channel) => (createdVia === "talk" ? "voice" : channel && !OPENCLAW_LOCAL.has(String(channel).toLowerCase()) ? "remote" : null);
+export function openclawHomes(given) {
+  if (given) return [given.replace(/^~(?=\/|$)/, homedir())];
+  const base = process.env.OPENCLAW_STATE_DIR || join(homedir(), ".openclaw");
+  try { return readdirSync(join(base, "agents")).sort().map((agent) => join(base, "agents", agent, "agent")); } catch { return []; }
+}
+const msOf = (value) => { const n = Number(value); return n > 1e11 ? n : n * 1000; };
+export function* openclawSessions(homes) {
+  for (const home of homes) {
+    const file = join(home, "openclaw-agent.sqlite");
+    try { if (!statSync(file).isFile()) continue; } catch { continue; }
+    const db = openDatabase(file);
+    if (!db) continue;
+    try {
+      const rows = db.prepare(`select w.session_id as id, n.created_via as via, coalesce(w.spawned_by, w.parent_session_key, n.spawned_by, n.parent_session_key) as parent, max(e.created_at) as last
+        from session_windows w join session_nodes n on n.session_key = w.session_key join transcript_events e on e.session_id = w.session_id group by w.session_id order by w.session_id`).all();
+      for (const row of rows) {
+        if (row.parent || OPENCLAW_UNATTENDED.has(row.via) || !/^[A-Za-z0-9_.:-]{1,120}$/.test(String(row.id))) continue;
+        yield { sessionId: String(row.id), file: `openclaw:${file}#${row.id}`, cwd: null, writtenAt: msOf(row.last) };
+      }
+    } catch { /* an older or foreign schema: not read */ } finally { db.close(); }
+  }
+}
+export function openclawLines(pseudo) {
+  const { file, id } = splitSession(pseudo);
+  const db = openDatabase(file);
+  if (!db) return null;
+  try {
+    const session = db.prepare("select n.created_via as via, w.channel as channel, w.model as model from session_windows w join session_nodes n on n.session_key = w.session_key where w.session_id = ?").get(id);
+    if (!session) return [];
+    const plain = db.prepare(`select seq, json_extract(event_json, '$.message.role') as role, json_extract(event_json, '$.message.timestamp') as at, json_extract(event_json, '$.message.model') as model,
+      json_extract(event_json, '$.message.usage.input') as input, json_extract(event_json, '$.message.usage.output') as output, json_extract(event_json, '$.message.usage.cacheRead') as cache_read, json_extract(event_json, '$.message.usage.cacheWrite') as cache_write
+      from transcript_events where session_id = ? and event_json is not null and json_extract(event_json, '$.type') = 'message'`).all(id);
+    const packed = db.prepare("select seq, event_zstd as packed from transcript_events where session_id = ? and event_json is null and event_zstd is not null").all(id).map(({ seq, packed: blob }) => {
+      try {
+        const event = JSON.parse(zlib.zstdDecompressSync(Buffer.from(blob)).toString("utf8"));
+        if (event?.type !== "message") return null;
+        const { role, timestamp, model, usage } = event.message ?? {};
+        return { seq, role, at: timestamp, model, input: usage?.input ?? null, output: usage?.output ?? null, cache_read: usage?.cacheRead ?? null, cache_write: usage?.cacheWrite ?? null };
+      } catch { return null; }
+    }).filter(Boolean);
+    const lines = [...plain, ...packed].filter((event) => Number.isFinite(Number(event.at))).sort((a, b) => a.seq - b.seq).map((event) => {
+      const timestamp = new Date(msOf(event.at)).toISOString();
+      if (event.role === "user") return { type: "user", timestamp, message: { content: [{ type: "text" }] } };
+      if (event.role === "toolResult") return { type: "user", timestamp, message: { content: [{ type: "tool_result" }] } };
+      const counted = event.input !== null || event.output !== null;
+      return { type: "assistant", timestamp, message: { model: cleanModel(event.model) ?? cleanModel(session.model), ...(counted ? { usage: { input_tokens: Number(event.input) || 0, output_tokens: Number(event.output) || 0, cache_read_input_tokens: Number(event.cache_read) || 0, cache_creation_input_tokens: Number(event.cache_write) || 0 } } : {}), content: [] } };
+    });
+    return [{ type: "meta", steered: openclawSteered(session.via, session.channel) }, ...lines];
+  } catch { return null; } finally { db.close(); }
+}
+// ── end openclaw session reader ──
+
+// ── cursor session reader ──
+/**
+ * CURSOR, READ FROM ITS OWN DATABASE (2026-10-06, the owner: "a person who works in Cursor all day has no measured
+ * hours"). Cursor keeps every chat ("composer") in one SQLite file, `User/globalStorage/state.vscdb` (~/Library/Application
+ * Support/Cursor on macOS, %APPDATA%\Cursor on Windows, ~/.config/Cursor on Linux), table cursorDiskKV: `composerData:<id>`
+ * per chat and `bubbleId:<id>:<bubble>` per message. Each message is read through json_extract INSIDE SQLite, its type
+ * (1 the person, 2 the model), its clock and its token counts, so no text ever leaves the database. A model message that
+ * carries a tool call is the loop's own step. The folder a chat belongs to is read from each workspace's own state
+ * (`composer.composerData`); a chat in no workspace has none. Needs node:sqlite (Node 22.5+).
+ */
+const userDirs = (app) => {
+  const base = platform() === "win32" && process.env.APPDATA ? process.env.APPDATA : platform() === "darwin" ? join(homedir(), "Library", "Application Support") : join(homedir(), ".config");
+  return [join(base, app, "User")];
+};
+const folderOf = (uri) => { try { return typeof uri === "string" && uri.startsWith("file://") ? decodeURIComponent(new URL(uri).pathname).replace(/^\/([A-Za-z]:)/, "$1") : null; } catch { return null; } };
+export function cursorHomes(given) { return given ? [given.replace(/^~(?=\/|$)/, homedir())] : userDirs("Cursor"); }
+/** Which folder each composer belongs to, from every workspace's own state. */
+function cursorFolders(home) {
+  const folders = new Map();
+  let dirs = []; try { dirs = readdirSync(join(home, "workspaceStorage")); } catch { return folders; }
+  for (const dir of dirs) {
+    let folder = null; try { folder = folderOf(JSON.parse(readFileSync(join(home, "workspaceStorage", dir, "workspace.json"), "utf8")).folder); } catch { continue; }
+    if (!folder) continue;
+    const db = openDatabase(join(home, "workspaceStorage", dir, "state.vscdb"));
+    if (!db) continue;
+    try {
+      const row = db.prepare("select json_extract(value, '$.allComposers') as ids from ItemTable where key = 'composer.composerData'").get();
+      for (const one of JSON.parse(row?.ids ?? "[]")) if (one?.composerId) folders.set(String(one.composerId), folder);
+    } catch { /* an older schema */ } finally { db.close(); }
+  }
+  return folders;
+}
+export function* cursorSessions(homes) {
+  for (const home of homes) {
+    const file = join(home, "globalStorage", "state.vscdb");
+    try { if (!statSync(file).isFile()) continue; } catch { continue; }
+    const folders = cursorFolders(home);
+    const db = openDatabase(file);
+    if (!db) continue;
+    try {
+      const rows = db.prepare("select substr(key, 14) as id, json_extract(value, '$.lastUpdatedAt') as last from cursorDiskKV where key like 'composerData:%'").all();
+      for (const row of rows) {
+        if (!/^[A-Za-z0-9_.:-]{1,120}$/.test(String(row.id))) continue;
+        yield { sessionId: String(row.id), file: `cursor:${file}#${row.id}`, cwd: folders.get(String(row.id)) ?? null, writtenAt: Number(row.last) || 0 };
+      }
+    } catch { /* an older or foreign schema: not read */ } finally { db.close(); }
+  }
+}
+export function cursorLines(pseudo) {
+  const { file, id } = splitSession(pseudo);
+  const db = openDatabase(file);
+  if (!db) return null;
+  try {
+    const chat = db.prepare("select json_extract(value, '$.modelConfig.modelName') as model from cursorDiskKV where key = ?").get(`composerData:${id}`);
+    const bubbles = db.prepare(`select json_extract(value, '$.type') as type, json_extract(value, '$.createdAt') as at,
+        json_extract(value, '$.tokenCount.inputTokens') as input, json_extract(value, '$.tokenCount.outputTokens') as output,
+        json_extract(value, '$.toolFormerData') is not null as tool
+      from cursorDiskKV where key > ? and key < ? and json_extract(value, '$.createdAt') is not null`).all(`bubbleId:${id}:`, `bubbleId:${id};`);
+    const model = cleanModel(chat?.model);
+    const lines = [];
+    for (const bubble of bubbles.sort((a, b) => String(a.at).localeCompare(String(b.at)))) {
+      const timestamp = new Date(bubble.at).toISOString();
+      if (Number(bubble.type) === 1) lines.push({ type: "user", timestamp, message: { content: [{ type: "text" }] } });
+      else if (Number(bubble.type) === 2) {
+        const usage = Number(bubble.input) || Number(bubble.output) ? { usage: { input_tokens: Number(bubble.input) || 0, output_tokens: Number(bubble.output) || 0 } } : {};
+        lines.push({ type: "assistant", timestamp, message: { model, ...usage, content: bubble.tool ? [{ type: "tool_use", name: "tool", input: {} }] : [] } });
+      }
+    }
+    return lines;
+  } catch { return null; } finally { db.close(); }
+}
+// ── end cursor session reader ──
+
+// ── copilot session reader ──
+/**
+ * GITHUB COPILOT IN VS CODE (2026-10-06). VS Code keeps each Copilot chat as a file: `chatSessions/<id>.jsonl` under
+ * every workspace's storage (`User/workspaceStorage/<hash>/`, its folder in `workspace.json`) and, for a window with no
+ * folder, under `User/globalStorage/emptyWindowChatSessions/`. A .jsonl file is a log of edits (kind 0 the whole
+ * session, 1 a value set at a path, 2 items appended at a path); an older .json file is the session whole. Each
+ * request is read for its clocks and counts only: when it was asked (`timestamp`, the person's turn) and when the
+ * model finished (`modelState.completedAt`), the model it resolved to and the prompt and output tokens. The messages,
+ * the responses and the tool calls' text are parsed with the file and never kept. Agent mode runs a request's tools
+ * between those two clocks without stamping each step, so under the same rule as every other client that span counts
+ * up to the idle cap, as one gap.
+ */
+export function copilotHomes(given) { return given ? [given.replace(/^~(?=\/|$)/, homedir())] : [...userDirs("Code"), ...userDirs("Code - Insiders")]; }
+export function* copilotSessions(homes) {
+  for (const home of homes) {
+    const places = [];
+    try { for (const dir of readdirSync(join(home, "workspaceStorage"))) places.push({ dir: join(home, "workspaceStorage", dir, "chatSessions"), workspace: join(home, "workspaceStorage", dir, "workspace.json") }); } catch { /* none */ }
+    places.push({ dir: join(home, "globalStorage", "emptyWindowChatSessions"), workspace: null });
+    for (const place of places) {
+      let names = []; try { names = readdirSync(place.dir); } catch { continue; }
+      let cwd = null; if (place.workspace) { try { cwd = folderOf(JSON.parse(readFileSync(place.workspace, "utf8")).folder); } catch { /* none */ } }
+      for (const name of names) {
+        const id = name.replace(/\.jsonl?$/, "");
+        if (!/\.jsonl?$/.test(name) || !/^[A-Za-z0-9_.:-]{1,120}$/.test(id)) continue;
+        let writtenAt = 0; try { writtenAt = statSync(join(place.dir, name)).mtimeMs; } catch { continue; }
+        yield { sessionId: id, file: `copilot:${join(place.dir, name)}#${id}`, cwd, writtenAt };
+      }
+    }
+  }
+}
+/** A session file back into the session: the whole object, or the edit log replayed. */
+function copilotSession(text, jsonl) {
+  if (!jsonl) return JSON.parse(text);
+  let session = null;
+  for (const raw of text.split("\n")) {
+    if (!raw.trim()) continue;
+    let edit; try { edit = JSON.parse(raw); } catch { continue; }
+    if (edit.kind === 0) { session = edit.v; continue; }
+    if (!session || !Array.isArray(edit.k) || edit.k.length === 0) continue;
+    const parent = edit.k.slice(0, -1).reduce((at, key) => (at == null ? at : at[key]), session);
+    const key = edit.k.at(-1);
+    if (parent == null || typeof parent !== "object") continue;
+    if (edit.kind === 1) parent[key] = edit.v;
+    else if (edit.kind === 2) { if (!Array.isArray(parent[key])) parent[key] = []; parent[key].push(...(Array.isArray(edit.v) ? edit.v : [edit.v])); }
+  }
+  return session;
+}
+export function copilotLines(pseudo) {
+  const { file } = splitSession(pseudo);
+  let session; try { session = copilotSession(readFileSync(file, "utf8"), file.endsWith(".jsonl")); } catch { return null; }
+  const lines = [];
+  for (const request of Array.isArray(session?.requests) ? session.requests : []) {
+    const asked = Number(request?.timestamp);
+    if (!Number.isFinite(asked) || asked <= 0) continue;
+    lines.push({ type: "user", timestamp: new Date(asked).toISOString(), message: { content: [{ type: "text" }] } });
+    const done = Number(request?.modelState?.completedAt) || (Number(request?.result?.timings?.totalElapsed) ? asked + Number(request.result.timings.totalElapsed) : 0);
+    if (!done || done < asked) continue;
+    const meta = request?.result?.metadata ?? {};
+    const usage = Number(meta.promptTokens) || Number(meta.outputTokens) ? { usage: { input_tokens: Number(meta.promptTokens) || 0, output_tokens: Number(meta.outputTokens) || 0 } } : {};
+    lines.push({ type: "assistant", timestamp: new Date(done).toISOString(), message: { model: cleanModel(String(meta.resolvedModel ?? request?.modelId ?? "").replace(/^copilot\//, "")), ...usage, content: [] } });
+  }
+  return lines;
+}
+// ── end copilot session reader ──
+
+// ── database clients ──
+/** The clients whose sessions live in a database, one registry: the hook and the counter ask it, not each client. */
+const DATABASE_CLIENTS = {
+  hermes: { homes: hermesHomes, sessions: hermesSessions, lines: hermesLines },
+  goose: { homes: gooseHomes, sessions: gooseSessions, lines: gooseLines },
+  opencode: { homes: opencodeHomes, sessions: opencodeSessions, lines: opencodeLines },
+  openclaw: { homes: openclawHomes, sessions: openclawSessions, lines: openclawLines },
+  cursor: { homes: cursorHomes, sessions: cursorSessions, lines: cursorLines },
+  copilot: { homes: copilotHomes, sessions: copilotSessions, lines: copilotLines },
+};
+export const DATABASE_SESSION = new RegExp(`^(${Object.keys(DATABASE_CLIENTS).join("|")}):.+#[A-Za-z0-9_.:-]{1,120}$`);
+/** Every attended session of every database client; `given` names a client's own home (a test), `onlyGiven` reads no other. */
+export function* databaseSessions(given = {}, onlyGiven = false) {
+  for (const [client, reader] of Object.entries(DATABASE_CLIENTS)) {
+    const homes = given[client] ? reader.homes(given[client]) : onlyGiven ? [] : reader.homes();
+    for (const session of reader.sessions(homes)) yield { client, ...session };
+  }
+}
+export const databaseLines = (pseudo) => DATABASE_CLIENTS[pseudo.slice(0, pseudo.indexOf(":"))]?.lines(pseudo) ?? null;
+// ── end database clients ──

package/setup-mcp.mjs

@@ -8,17 +8,18 @@
  *   node setup-mcp.mjs --remove --write                                             (takes it out again)
  *
  * One machine, one token, many clients: Claude Code, Cursor, Codex, Gemini CLI, VS Code's
- * Copilot agent mode, Windsurf, Mistral Vibe, Google Antigravity, Grok Build, Zed, Cline. Each keeps its own config file in its own shape; this finds
+ * Copilot agent mode, Windsurf, Mistral Vibe, Google Antigravity, Grok Build, Zed, Cline, Hermes Agent, Goose. Each keeps its own config file in its own shape; this finds
  * the ones that exist here and adds the same WorkTrust server to each, so a coupling made once
  * counts everywhere — and every client names itself when it first speaks, which is how Sources
  * shows each product as coupled. Without --write nothing is touched. The token is shown
  * masked; it lives only in the files it is written to. A config that already names the server
  * is left as it is.
  */
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
+import { placeUnder, takeOut } from "./config-edits.mjs";
 
 const args = process.argv.slice(2);
 const value = (name) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : undefined; };
@@ -67,12 +68,109 @@ const masked = BRIDGE ? "kept in ~/.worktrust/key.json, not in these files" : `$
 const stdio = { command: NODE, args: [BRIDGE ?? "", "mcp"] };
 const home = homedir();
 /** Whether Claude Code's own command is on this machine: asked of the shell, never guessed from a file. */
-const claudeOnPath = () => spawnSync(platform() === "win32" ? "where" : "which", ["claude"], { encoding: "utf8", shell: platform() === "win32" }).status === 0;
+const onPath = (command) => spawnSync(platform() === "win32" ? "where" : "which", [command], { encoding: "utf8", shell: platform() === "win32" }).status === 0;
+const claudeOnPath = () => onPath("claude");
 const VIBE_DIR = process.env.VIBE_HOME?.trim() || join(home, ".vibe");
 const GROK_DIR = process.env.GROK_HOME?.trim() || join(home, ".grok");
 const ZED_DIR = platform() === "win32" ? join(process.env.APPDATA ?? home, "Zed") : join(home, ".config", "zed");
 const vscodeUser = platform() === "darwin" ? join(home, "Library", "Application Support", "Code", "User") : platform() === "win32" ? join(process.env.APPDATA ?? home, "Code", "User") : join(home, ".config", "Code", "User");
 const CLINE_DIR = join(vscodeUser, "globalStorage", "saoudrizwan.claude-dev", "settings");
+/**
+ * HERMES AGENT (Nous Research, 2026-10-05): `mcp_servers` in config.yaml under its home (~/.hermes, %LOCALAPPDATA%/hermes
+ * on Windows, HERMES_HOME) and under every profile's own home (profiles/<name>), `command`/`args` for a local server,
+ * `url`/`headers` for a remote one (hermes-agent.nousresearch.com/docs/user-guide/features/mcp). With the bridge it also
+ * gets one shell hook on `on_session_end` that wakes the session hook, which reads Hermes's own session database
+ * (features/hooks); Hermes asks the person once before it runs a new hook. YAML is edited line by line and only in
+ * block style: a file whose sections are written inline is left alone and the entry printed to add by hand.
+ */
+const HERMES_BASE = platform() === "win32" && process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "hermes") : join(home, ".hermes");
+const hermesHomes = () => {
+  const homes = new Set([HERMES_BASE, ...(process.env.HERMES_HOME ? [process.env.HERMES_HOME] : [])]);
+  try { for (const name of readdirSync(join(HERMES_BASE, "profiles")).sort()) homes.add(join(HERMES_BASE, "profiles", name)); } catch { /* no profiles */ }
+  return [...homes].filter((dir) => existsSync(dir));
+};
+const HERMES_HOOK = `"${NODE}" "${BRIDGE ?? ""}" hook --hermes`;
+const ours = (text) => text.includes(URL_) || /worktrust\.mjs/.test(text);
+/** A YAML client's file with our entry (and hook) taken out and, unless removing, put back in; null when it cannot be. */
+function yamlConfig(client, text, remove) {
+  const lines = text.trim() === "" ? [] : text.replace(/\n$/, "").split("\n");
+  takeOut(lines, [client.root], (unit) => new RegExp(`^\\s*${NAME}:`).test(unit) || ours(unit));
+  if (client.hook) takeOut(lines, client.hook.path, ours);
+  if (!remove) {
+    if (!placeUnder(lines, [client.root], client.server)) return null;
+    if (client.hook && BRIDGE && !placeUnder(lines, client.hook.path, client.hook.unit)) return null;
+  }
+  return lines.length ? `${lines.join("\n")}\n` : "";
+}
+const bridgeOrUrl = (local, remote) => (BRIDGE ? local : remote);
+const HERMES_SERVER = bridgeOrUrl([`${NAME}:`, `  command: ${JSON.stringify(NODE)}`, `  args: [${JSON.stringify(BRIDGE)}, "mcp"]`], [`${NAME}:`, `  url: ${JSON.stringify(URL_)}`, "  headers:", `    Authorization: ${JSON.stringify(`Bearer ${TOKEN}`)}`]);
+/**
+ * GOOSE (2026-10-05, aaif-goose/goose: crates/goose/src/config/extensions.rs, agents/extension.rs; documentation
+ * guides/config-files.md): `extensions` in config.yaml (~/.config/goose, %APPDATA%\\Block\\goose\\config on Windows,
+ * <GOOSE_PATH_ROOT>/config), each entry `type: stdio` with `cmd` and `args`, or `type: streamable_http` with `uri` and
+ * `headers`. Its hooks come from Open Plugins folders (~/.agents/plugins/<name>/plugin.json + hooks/hooks.json,
+ * guides/context-engineering/hooks.md); with the bridge one plugin named worktrust runs the session hook on SessionEnd.
+ */
+const GOOSE_SERVER = bridgeOrUrl(
+  [`${NAME}:`, "  type: stdio", `  name: ${NAME}`, "  enabled: true", `  cmd: ${JSON.stringify(NODE)}`, `  args: [${JSON.stringify(BRIDGE)}, "mcp"]`, "  envs: {}", "  timeout: 300"],
+  [`${NAME}:`, "  type: streamable_http", `  name: ${NAME}`, "  enabled: true", `  uri: ${JSON.stringify(URL_)}`, "  headers:", `    Authorization: ${JSON.stringify(`Bearer ${TOKEN}`)}`, "  envs: {}", "  timeout: 300"],
+);
+const gooseDirs = () => [...new Set([...(process.env.GOOSE_PATH_ROOT ? [join(process.env.GOOSE_PATH_ROOT, "config")] : []), join(home, ".config", "goose"), ...(platform() === "win32" && process.env.APPDATA ? [join(process.env.APPDATA, "Block", "goose", "config")] : [])])].filter((dir) => existsSync(dir));
+const GOOSE_PLUGIN = join(process.env.GOOSE_PATH_ROOT || home, ".agents", "plugins", NAME);
+const GOOSE_HOOKS = { hooks: { SessionEnd: [{ hooks: [{ type: "command", command: `"${NODE}" "${BRIDGE ?? ""}" hook --goose`, timeout: 30 }] }] } };
+const goosePluginStands = () => { try { return JSON.stringify(JSON.parse(readFileSync(join(GOOSE_PLUGIN, "hooks", "hooks.json"), "utf8"))) === JSON.stringify(GOOSE_HOOKS); } catch { return false; } };
+/** Our plugin folder in, or out; another plugin is never touched, and a folder of that name that is not ours stays. */
+function goosePlugin(remove) {
+  let manifest = null; try { manifest = JSON.parse(readFileSync(join(GOOSE_PLUGIN, "plugin.json"), "utf8")); } catch { /* none */ }
+  if (existsSync(GOOSE_PLUGIN) && manifest?.description !== GOOSE_DESCRIPTION) return false;
+  if (remove) { rmSync(GOOSE_PLUGIN, { recursive: true, force: true }); return true; }
+  mkdirSync(join(GOOSE_PLUGIN, "hooks"), { recursive: true });
+  writeFileSync(join(GOOSE_PLUGIN, "plugin.json"), `${JSON.stringify({ name: NAME, version: "1.0.0", description: GOOSE_DESCRIPTION }, null, 2)}\n`);
+  writeFileSync(join(GOOSE_PLUGIN, "hooks", "hooks.json"), `${JSON.stringify(GOOSE_HOOKS, null, 2)}\n`);
+  return true;
+}
+const GOOSE_DESCRIPTION = "WorkTrust: wakes the WorkTrust session hook when a goose session ends (counts only, never content).";
+
+/**
+ * OPENCODE (2026-10-05, anomalyco/opencode: packages/core/src/v1/config/mcp.ts, opencode.ai/docs/mcp-servers): `mcp` in
+ * ~/.config/opencode/opencode.json(c) (XDG_CONFIG_HOME moves it), `type: "local"` with `command` as one array, or
+ * `type: "remote"` with `url` and `headers`. A file with comments is left alone, as for Zed. With the bridge one plugin
+ * file, plugin/worktrust.js, wakes the session hook when a session goes idle (opencode.ai/docs/plugins: `session.idle`).
+ */
+const OPENCODE_DIR = join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "opencode");
+const OPENCODE_FILE = ["opencode.jsonc", "opencode.json", "config.json"].map((name) => join(OPENCODE_DIR, name)).find((file) => existsSync(file)) ?? join(OPENCODE_DIR, "opencode.json");
+const OPENCODE_PLUGIN = join(OPENCODE_DIR, "plugin", `${NAME}.js`);
+const OPENCODE_MARK = "// WorkTrust: wakes the WorkTrust session hook when an OpenCode session goes idle (counts only, never content).";
+const OPENCODE_PLUGIN_TEXT = `${OPENCODE_MARK}
+import { spawn } from "node:child_process";
+let last = 0;
+export const WorkTrust = async () => ({
+  event: async ({ event }) => {
+    if (event?.type !== "session.idle" || Date.now() - last < 30_000) return;
+    last = Date.now();
+    try { spawn(${JSON.stringify(NODE)}, [${JSON.stringify(BRIDGE ?? "")}, "hook"], { detached: true, stdio: "ignore" }).unref(); } catch { /* the next run sweeps it */ }
+  },
+});
+`;
+/** Our plugin file in, or out; a file of that name that is not ours stays. */
+function opencodePlugin(remove) {
+  let text = null; try { text = readFileSync(OPENCODE_PLUGIN, "utf8"); } catch { /* none */ }
+  if (text !== null && !text.startsWith(OPENCODE_MARK)) return false;
+  if (remove) { rmSync(OPENCODE_PLUGIN, { force: true }); return true; }
+  mkdirSync(dirname(OPENCODE_PLUGIN), { recursive: true });
+  writeFileSync(OPENCODE_PLUGIN, OPENCODE_PLUGIN_TEXT);
+  return true;
+}
+const opencodePluginStands = () => { try { return readFileSync(OPENCODE_PLUGIN, "utf8") === OPENCODE_PLUGIN_TEXT; } catch { return false; } };
+/**
+ * OPENCLAW (2026-10-05, openclaw/openclaw: docs/cli/mcp/registry.md, transports.md): its servers live under `mcp.servers`
+ * in ~/.openclaw/openclaw.json, a JSON5 file OpenClaw replaces atomically, so it is never edited here: `openclaw mcp set
+ * <name> <json>` writes the entry and `openclaw mcp unset <name>` takes it out (config only, no connection is made).
+ * Without the `openclaw` command on this machine's PATH the command is printed to run. OpenClaw runs no shell hook; its
+ * sessions are read whenever another client's hook runs.
+ */
+const OPENCLAW_FILE = process.env.OPENCLAW_CONFIG_PATH || join(process.env.OPENCLAW_STATE_DIR || join(home, ".openclaw"), "openclaw.json");
+const OPENCLAW_ENTRY = BRIDGE ? { command: NODE, args: [BRIDGE, "mcp"] } : { url: URL_, transport: "streamable-http", headers: { Authorization: `Bearer ${TOKEN}` } };
 
 /** Each client: where it lives, how it says "an HTTP MCP server with a header". */
 const CLIENTS = [
@@ -96,6 +194,10 @@ const CLIENTS = [
   // CLINE (docs.cline.bot/mcp): `mcpServers` in the extension's cline_mcp_settings.json; `type` must be
   // "streamableHttp" exactly, or Cline falls back to SSE and the door answers 405.
   { key: "cline", label: "Cline (VS Code)", present: () => existsSync(CLINE_DIR), file: join(CLINE_DIR, "cline_mcp_settings.json"), shape: "json", root: "mcpServers", entry: BRIDGE ? { ...stdio, disabled: false } : { type: "streamableHttp", url: URL_, headers: { Authorization: `Bearer ${TOKEN}` }, disabled: false } },
+  ...hermesHomes().map((dir) => ({ key: "hermes", label: dir === HERMES_BASE ? "Hermes Agent" : `Hermes Agent (${dir.split(/[\\/]/).pop()})`, present: () => true, file: join(dir, "config.yaml"), shape: "yaml", root: "mcp_servers", server: HERMES_SERVER, hook: { path: ["hooks", "on_session_end"], unit: [`- command: ${JSON.stringify(HERMES_HOOK)}`, "  timeout: 30"], note: "an on_session_end hook (Hermes asks once before it runs it)" } })),
+  ...gooseDirs().map((dir) => ({ key: "goose", label: "Goose", present: () => true, file: join(dir, "config.yaml"), shape: "yaml", root: "extensions", server: GOOSE_SERVER, plugin: true })),
+  { key: "opencode", label: "OpenCode", present: () => existsSync(OPENCODE_DIR), file: OPENCODE_FILE, shape: "json", root: "mcp", entry: BRIDGE ? { type: "local", command: [NODE, BRIDGE, "mcp"], enabled: true } : { type: "remote", url: URL_, headers: { Authorization: `Bearer ${TOKEN}` }, enabled: true }, plugin: "opencode" },
+  { key: "openclaw", label: "OpenClaw", present: () => existsSync(dirname(OPENCLAW_FILE)) || onPath("openclaw"), file: OPENCLAW_FILE, shape: "openclaw" },
   { key: "claude", label: "Claude Code", present: () => existsSync(join(home, ".claude.json")), file: join(home, ".claude.json"), shape: "claude" },
 ];
 
@@ -104,6 +206,19 @@ let touched = 0;
 let standing = 0;
 for (const client of CLIENTS) {
   if (!client.present()) { console.log(`  – ${client.label}: not on this machine`); continue; }
+  if (client.shape === "openclaw") {
+    const text = existsSync(client.file) ? readFileSync(client.file, "utf8") : "";
+    const named = new RegExp(`["']?${NAME}["']?\\s*:\\s*\\{`).test(text) && ours(text);
+    const verb = REMOVE ? ["mcp", "unset", NAME] : ["mcp", "set", NAME, JSON.stringify(OPENCLAW_ENTRY)];
+    const shown = `openclaw ${verb.slice(0, 3).join(" ")}${REMOVE ? "" : ` '${JSON.stringify(OPENCLAW_ENTRY).replace(/Bearer [^"]+/, "Bearer <token>")}'`}`;
+    if (REMOVE ? !named : named && text.includes(JSON.stringify(BRIDGE ?? URL_).slice(1, -1)) && (BRIDGE === undefined || !text.includes(URL_))) { console.log(REMOVE ? `  – ${client.label}: does not name the door` : `  ✓ ${client.label}: already names the door (${client.file})`); if (!REMOVE) standing += 1; continue; }
+    if (!WRITE) { console.log(`  ${REMOVE ? "−" : "+"} ${client.label}: would run ${shown}`); continue; }
+    if (!onPath("openclaw")) { console.log(`  ! ${client.label}: the \`openclaw\` command is not on this machine's PATH; run ${shown}`); continue; }
+    const run = spawnSync("openclaw", verb, { encoding: "utf8", shell: platform() === "win32" });
+    if (run.status === 0) { console.log(`  ${REMOVE ? "−" : "+"} ${client.label}: ${REMOVE ? "removed" : "coupled"} through \`openclaw mcp ${REMOVE ? "unset" : "set"}\``); touched += 1; }
+    else console.log(`  ! ${client.label}: \`openclaw mcp\` refused (${(run.stderr || run.stdout || "").trim().split("\n")[0] || "no output"}); run it yourself: ${shown}`);
+    continue;
+  }
   if (client.shape === "claude") {
     // Claude Code owns this file and has its own verb for it, so this never edits the file: it RUNS
     // the verb when the `claude` command is on this machine (2026-09-28; before, the line was only
@@ -131,7 +246,7 @@ for (const client of CLIENTS) {
   }
   const text = existsSync(client.file) ? readFileSync(client.file, "utf8") : "";
   // With the bridge, coupled means the bridge is in AND no entry with a key in it is left beside it.
-  const already = REMOVE ? text.includes(URL_) || /worktrust\.mjs/.test(text) : BRIDGE !== undefined ? text.includes(JSON.stringify(BRIDGE).slice(1, -1)) && !text.includes(URL_) : text.includes(URL_);
+  const already = client.shape === "yaml" && !REMOVE ? (BRIDGE !== undefined ? text.includes(JSON.stringify(BRIDGE)) && (!client.plugin || goosePluginStands()) : text.includes(URL_)) && yamlConfig(client, text, false) === text : REMOVE ? text.includes(URL_) || /worktrust\.mjs/.test(text) : BRIDGE !== undefined ? text.includes(JSON.stringify(BRIDGE).slice(1, -1)) && !text.includes(URL_) : text.includes(URL_);
   // THE WAY OUT, ON THE MACHINE. Uncoupling in the app ends the TOKEN; the config that names the
   // door stays behind on every client here, so the next person to read this file believes the
   // machine is coupled. `--remove` takes the entry out; the account side is a separate act and
@@ -148,8 +263,12 @@ for (const client of CLIENTS) {
         if (key === NAME || named) delete root[key];
       }
       config[client.root] = root;
-      console.log(`  − ${client.label}: ${WRITE ? "removed from" : "would remove from"} ${client.file}`);
-      if (WRITE) writeFileSync(client.file, JSON.stringify(config, null, 2) + "\n");
+      console.log(`  − ${client.label}: ${WRITE ? "removed from" : "would remove from"} ${client.file}${client.plugin && existsSync(OPENCODE_PLUGIN) ? ` and ${OPENCODE_PLUGIN}` : ""}`);
+      if (WRITE) { writeFileSync(client.file, JSON.stringify(config, null, 2) + "\n"); if (client.plugin) opencodePlugin(true); }
+    } else if (client.shape === "yaml") {
+      const next = yamlConfig(client, readFileSync(client.file, "utf8"), true);
+      console.log(`  − ${client.label}: ${WRITE ? "removed from" : "would remove from"} ${client.file}${client.plugin && existsSync(GOOSE_PLUGIN) ? ` and ${GOOSE_PLUGIN}` : ""}`);
+      if (WRITE) { writeFileSync(client.file, next); if (client.plugin) goosePlugin(true); }
     } else if (client.shape === "vibe") {
       // Vibe's servers are an ARRAY of tables, so a block is found by what it says, not by its header: every
       // `[[mcp_servers]]` that names ours, the door, or the bridge goes, up to the next header at a line start.
@@ -170,7 +289,7 @@ for (const client of CLIENTS) {
     touched += 1;
     continue;
   }
-  if (already) { console.log(`  ✓ ${client.label}: already names the door (${client.file})`); standing += 1; continue; }
+  if (already && !(client.plugin === "opencode" && BRIDGE && !opencodePluginStands())) { console.log(`  ✓ ${client.label}: already names the door (${client.file})`); standing += 1; continue; }
   if (client.shape === "json") {
     let config = {};
     // NEVER OVERWRITE WHAT DOES NOT PARSE (2026-10-04): Zed's and VS Code's settings allow comments and trailing
@@ -182,8 +301,20 @@ for (const client of CLIENTS) {
       continue;
     }
     config[client.root] = { ...(config[client.root] ?? {}), [NAME]: client.entry };
-    console.log(`  + ${client.label}: ${WRITE ? "wrote" : "would write"} ${client.file} → ${client.root}.${NAME}`);
-    if (WRITE) { mkdirSync(dirname(client.file), { recursive: true }); writeFileSync(client.file, JSON.stringify(config, null, 2) + "\n"); touched += 1; }
+    console.log(`  + ${client.label}: ${WRITE ? "wrote" : "would write"} ${client.file} → ${client.root}.${NAME}${client.plugin && BRIDGE ? ` and ${OPENCODE_PLUGIN}` : ""}`);
+    if (WRITE) {
+      mkdirSync(dirname(client.file), { recursive: true }); writeFileSync(client.file, JSON.stringify(config, null, 2) + "\n"); touched += 1;
+      if (client.plugin && BRIDGE && !opencodePlugin(false)) console.log(`  ! ${client.label}: ${OPENCODE_PLUGIN} exists and is not WorkTrust's, so no plugin was written; OpenCode sessions are still read whenever another hook runs`);
+    }
+  } else if (client.shape === "yaml") {
+    const next = yamlConfig(client, text, false);
+    if (next === null) { console.log(`  ! ${client.label}: ${client.file} writes ${client.root}${client.hook ? " or hooks" : ""} inline, so it is left as it is. Add under ${client.root}:\n    ${client.server.join("\n    ")}`); continue; }
+    const hookNote = !BRIDGE ? "" : client.hook ? ` and ${client.hook.note}` : client.plugin ? ` and a SessionEnd hook in ${GOOSE_PLUGIN}` : "";
+    console.log(`  + ${client.label}: ${WRITE ? "wrote" : "would write"} ${client.file} → ${client.root}.${NAME}${hookNote}`);
+    if (WRITE) {
+      mkdirSync(dirname(client.file), { recursive: true }); writeFileSync(client.file, next); touched += 1;
+      if (client.plugin && BRIDGE && !goosePlugin(false)) console.log(`  ! ${client.label}: ${GOOSE_PLUGIN} exists and is not WorkTrust's, so no hook was written; goose sessions are still read whenever another hook runs`);
+    }
   } else if (client.shape === "toml" || client.shape === "vibe") {
     console.log(`  + ${client.label}: ${WRITE ? "appended to" : "would append to"} ${client.file} → ${client.shape === "vibe" ? `[[mcp_servers]] name = "${NAME}"` : `[mcp_servers.${NAME}]`}`);
     if (WRITE) { mkdirSync(dirname(client.file), { recursive: true }); writeFileSync(client.file, (existsSync(client.file) ? readFileSync(client.file, "utf8") : "") + client.block); touched += 1; }

package/worktrust.mjs

@@ -49,7 +49,7 @@
  *
  * No dependencies: Node 18 or later.
  */
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { createHash, generateKeyPairSync, randomBytes, sign } from "node:crypto";
 import { createServer } from "node:http";
 import { chmodSync, closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
@@ -65,14 +65,15 @@ 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.6.9";
+const CLI_VERSION = "0.6.11";
 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");
 const HERE = dirname(fileURLToPath(import.meta.url));
-const SCRIPTS = ["setup-mcp.mjs", "log-session.mjs", "count-behaviour.mjs", "transcript-readers.mjs"];
-/** The readers are imported by name from beside the scripts, so a download keeps that name. */
-const downloaded = (name) => (name === "transcript-readers.mjs" ? name : `${name}.download.mjs`);
+const SCRIPTS = ["setup-mcp.mjs", "log-session.mjs", "count-behaviour.mjs", "transcript-readers.mjs", "session-databases.mjs", "config-edits.mjs"];
+/** The modules the scripts import by name from beside them; a download keeps that name. */
+const IMPORTED = new Set(["transcript-readers.mjs", "session-databases.mjs", "config-edits.mjs"]);
+const downloaded = (name) => (IMPORTED.has(name) ? name : `${name}.download.mjs`);
 const BUNDLED = SCRIPTS.every((name) => existsSync(join(HERE, name)));
 const PLACEHOLDER = `wt_${"0".repeat(43)}`;
 const say = (line = "") => process.stdout.write(`${line}\n`);
@@ -80,6 +81,28 @@ const fail = (line) => { process.stderr.write(`worktrust: ${line}\n`); process.e
 const OS = { darwin: "macos", win32: "windows", linux: "linux" }[platform()] ?? "other";
 const OS_NAME = { macos: "macOS", windows: "Windows", linux: "Linux", other: "this system" }[OS];
 
+/**
+ * WHICH COMPUTER, WHICH PROFILE (0.6.10, owner 2026-10-05: one computer coupled twice sent its history twice). The
+ * machine's own id (macOS hardware UUID, Windows MachineGuid, Linux machine-id) and, for the profile, that id with this
+ * user's home folder: two people or two environments on one computer stay two. Only one-way hashes leave the computer,
+ * and WorkTrust keeps them only mixed with the account, so the same machine under two accounts matches nothing.
+ * A machine whose id cannot be read sends nothing, and is a computer as before.
+ */
+function machineId() {
+  try {
+    if (OS === "macos") return execFileSync("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], { encoding: "utf8", timeout: 3000 }).match(/"IOPlatformUUID" = "([0-9A-Fa-f-]{36})"/)?.[1] ?? null;
+    if (OS === "windows") return execFileSync("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"], { encoding: "utf8", timeout: 3000 }).match(/MachineGuid\s+REG_SZ\s+([0-9A-Fa-f-]{36})/)?.[1] ?? null;
+    if (OS === "linux") for (const file of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) if (existsSync(file)) { const id = readFileSync(file, "utf8").trim(); if (/^[0-9a-f]{32}$/.test(id)) return id; }
+  } catch { /* unreadable: no identity */ }
+  return null;
+}
+function computerIds() {
+  const machine = machineId();
+  if (!machine) return {};
+  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()}`) };
+}
+
 if (Number(process.versions.node.split(".")[0]) < 18) fail("needs Node 18 or later (fetch is built in from 18).");
 
 async function post(path, body) {
@@ -154,10 +177,14 @@ async function pairByBrowser(host, extra) {
   const state = randomBytes(24).toString("base64url");
   let deliver;
   const answer = new Promise((resolve) => { deliver = resolve; });
+  // Where the browser goes once this terminal has its code (0.6.11, owner 2026-10-06): WorkTrust's own "connected" page in
+  // the house style, not a bare page on 127.0.0.1. Known once the pairing has its code; until then the plain page.
+  let doneUrl = null;
   const server = createServer((request, response) => {
     const url = new URL(request.url ?? "/", "http://127.0.0.1");
     if (url.pathname !== "/callback" || url.searchParams.get("state") !== state || !url.searchParams.get("code")) { response.writeHead(404).end(); return; }
-    response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(DONE_PAGE);
+    if (doneUrl) response.writeHead(303, { location: doneUrl, "cache-control": "no-store" }).end();
+    else response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(DONE_PAGE);
     deliver(url.searchParams.get("code"));
   });
   await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
@@ -166,6 +193,7 @@ async function pairByBrowser(host, extra) {
   if (!pairing) { server.close(); fail(`cannot reach ${ORIGIN}.`); }
   if (pairing.status !== 200) { server.close(); fail(pairing.json.error === "rate_limited" ? "too many attempts from this network; wait a minute." : `pairing refused (${pairing.json.error ?? pairing.status}).`); }
   const { device_code: secret, authorize_url: url, user_code: shown, expires_in: lifetime = 600, features = [] } = pairing.json;
+  doneUrl = `${ORIGIN}/connect/computer/done?code=${encodeURIComponent(shown)}`;
   if (!features.includes("loopback")) { server.close(); fail(`${ORIGIN} is older than this command. Use the command WorkTrust shows under Sources → Add a computer.`); }
   say();
   say(`  Your code:  ${shown}  (the WorkTrust page shows the same; approve only if it matches)`);
@@ -323,10 +351,30 @@ function withLock(work) {
   return work().finally(() => { closeSync(handle); try { rmSync(LOCK_FILE); } catch { /* gone */ } });
 }
 
+/**
+ * A KEY FILE ON OTHER HARDWARE (0.6.10, owner 2026-10-05: "a backup restored onto a new device must not upload to the
+ * passport unseen"). The key file remembers the profile it was made on; on any other computer it sends nothing, and
+ * WorkTrust is told once (`/api/cli/moved`), so the key is ended and the owner sees it. `npx worktrust connect` couples this one.
+ */
+async function copiedHere(key) {
+  const here = computerIds().profile_id;
+  if (!key.profile || !here || key.profile === here) return false;
+  try {
+    // Its own door, which only ends and marks the key: nothing is renewed, so no new secret is ever announced here.
+    const url = `${new URL(key.url).origin}/api/cli/moved`, body = JSON.stringify(computerIds());
+    await fetch(url, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${key.token}`, ...proof(key.device, url, body) }, body });
+  } catch { /* offline: it is told next time */ }
+  process.stderr.write("WorkTrust: this key was made on another computer (copied from a backup?). Nothing is sent from here; run `npx worktrust connect` on this computer.\n");
+  return true;
+}
+
 async function freshKey() {
   const first = keyStore.load();
   if (!first) return null;
-  if (!first.pending && Date.now() - Date.parse(first.renewedAt ?? 0) < RENEW_EVERY_MS) return first;
+  if (await copiedHere(first)) return null;
+  // A key made before 0.6.10 renews now, once: the renewal carries the computer's identity. `identified` means it was
+  // tried, so a machine whose id cannot be read does not renew on every use.
+  if (!first.pending && first.identified && Date.now() - Date.parse(first.renewedAt ?? 0) < RENEW_EVERY_MS) return first;
   const settled = await withLock(async () => {
     const value = keyStore.load();
     if (!value) return null;
@@ -335,14 +383,15 @@ async function freshKey() {
       if (next === true) { const promoted = { ...value, token: value.pending, renewedAt: new Date().toISOString() }; delete promoted.pending; keyStore.save(promoted); return promoted; }
       if (next === false) { delete value.pending; keyStore.save(value); }
     }
-    if (Date.now() - Date.parse(value.renewedAt ?? 0) < RENEW_EVERY_MS) return value;
+    if (value.identified && Date.now() - Date.parse(value.renewedAt ?? 0) < RENEW_EVERY_MS) return value;
     const pending = `wt_${randomBytes(32).toString("base64url")}`;
     keyStore.save({ ...value, pending });
     try {
       const renewUrl = `${new URL(value.url).origin}/api/cli/renew`;
-      const body = JSON.stringify({ token_hash: createHash("sha256").update(pending).digest("hex"), token_prefix: pending.slice(0, 11) });
+      const ids = computerIds();
+      const body = JSON.stringify({ token_hash: createHash("sha256").update(pending).digest("hex"), token_prefix: pending.slice(0, 11), ...ids });
       const response = await fetch(renewUrl, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${value.token}`, ...proof(value.device, renewUrl, body) }, body });
-      if (response.ok) { const renewed = { ...value, token: pending, renewedAt: new Date().toISOString() }; keyStore.save(renewed); return renewed; }
+      if (response.ok) { const renewed = { ...value, token: pending, renewedAt: new Date().toISOString(), identified: true, profile: value.profile ?? ids.profile_id }; keyStore.save(renewed); return renewed; }
       // Refused: drop the pending key only if the file still holds the value this renewal read.
       if (response.status === 400 || response.status === 401) { const now = keyStore.load(); if (now?.token === value.token && now?.pending === pending) keyStore.save(value); }
     } catch { /* offline: the pending key is settled next time */ }
@@ -359,8 +408,21 @@ async function freshKey() {
  * the key from the key file, answers on stdout. It names the app that started it (from `initialize`),
  * so WorkTrust still sees Claude Code or Cursor, not the bridge.
  */
+/**
+ * A SWEEP WHEN AN AI APP OPENS THE DOOR (0.6.11, owner 2026-10-06). Cursor and VS Code run no hook WorkTrust can give
+ * them, so the session hook never woke for a person who works there all day; both do start this bridge whenever they
+ * open. So the bridge starts the sweep once, detached and silent (stdout stays the MCP channel), at most once an hour.
+ */
+function sweepAtMostHourly() {
+  const stamp = join(HOME_DIR, "bridge-swept-at");
+  try { if (Date.now() - Number(readFileSync(stamp, "utf8")) < 3_600_000) return; } catch { /* never swept here */ }
+  try { mkdirSync(HOME_DIR, { recursive: true }); writeFileSync(stamp, String(Date.now())); } catch { return; }
+  try { spawn(process.execPath, [fileURLToPath(import.meta.url), "hook"], { detached: true, stdio: "ignore" }).unref(); } catch { /* the next start sweeps */ }
+}
+
 async function bridge() {
   let key = await freshKey();
+  if (key) sweepAtMostHourly();
   const answer = (id, message) => process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32603, message } })}\n`);
   let session = null;
   let agent = "worktrust-bridge";
@@ -395,6 +457,7 @@ async function bridge() {
 /** THE HOOK Claude Code runs (`worktrust.mjs hook`): the key from the key file, handed to the session hook. */
 async function hook() {
   if (has("antigravity-stop")) return antigravityStop();
+  if (has("hermes") || has("goose")) return sessionEnd();
   const key = await freshKey();
   if (!key) process.exit(0);
   const child = spawn(process.execPath, [join(HOME_DIR, "log-session.mjs"), ...args.filter((arg) => arg !== "hook")], { stdio: "inherit", env: { ...process.env, WORKTRUST_MCP_URL: key.url, WORKTRUST_MCP_TOKEN: key.token, ...(key.device ? { WORKTRUST_DEVICE_KEY: key.device } : {}) } });
@@ -424,6 +487,20 @@ async function antigravityStop() {
   process.exit(0);
 }
 
+/**
+ * A SESSION-END HOOK THAT READS JSON AND ANSWERS JSON: Hermes Agent's (`hook --hermes`) and Goose's SessionEnd
+ * (`hook --goose`, an Open Plugins hook: JSON on stdin, run with sh -c), 2026-10-05. Hermes pipes a JSON payload (ids, the
+ * model, the platform; no message body) to a shell hook on every `on_session_end` and reads stdout as JSON
+ * (hermes-agent.nousresearch.com/docs/user-guide/features/hooks). This answers `{}` (nothing to change), reads and drops
+ * the payload, and runs the sweep detached: the session hook reads Hermes's own database (transcript-readers.mjs).
+ */
+async function sessionEnd() {
+  writeSync(1, "{}\n");
+  if (!process.stdin.isTTY) await new Promise((resolve) => { const timer = setTimeout(resolve, 2000); process.stdin.on("data", () => {}); process.stdin.on("end", () => { clearTimeout(timer); resolve(); }); process.stdin.on("error", () => { clearTimeout(timer); resolve(); }); });
+  try { spawn(process.execPath, [fileURLToPath(import.meta.url), "hook"], { detached: true, stdio: "ignore" }).unref(); } catch { /* the next run sweeps it */ }
+  process.exit(0);
+}
+
 /**
  * `npx worktrust update` (owner, 2026-10-04): THIS COMPUTER ONTO THE NEWEST CLI, WITHOUT PAIRING IT
  * AGAIN. `connect` mints a new key and so a new device row to merge; an update keeps the key and the
@@ -504,7 +581,7 @@ async function connect() {
   // The device key: made here, its private half kept with the key, its public half bound at WorkTrust.
   const device = direct ? null : generateKeyPairSync("ed25519");
   const apps = foundApps.map((line) => /^\s*[↻+✓] ([^:]+):/.exec(line)?.[1]).filter(Boolean).slice(0, 12);
-  const extra = { apps, ...(device ? { device_key: device.publicKey.export({ format: "jwk" }).x } : {}) };
+  const extra = { apps, ...computerIds(), ...(device ? { device_key: device.publicKey.export({ format: "jwk" }).x } : {}) };
   const pairing = useDevice() ? await pairByCode(host, extra) : await pairByBrowser(host, extra);
   const { token } = pairing;
   // ANOTHER ACCOUNT THAN BEFORE: told by the opaque account names. Unknown counts as another, the safe side.
@@ -514,7 +591,7 @@ async function connect() {
   // Out first, then in: an app that already held a WorkTrust key moves to the new one.
   await run(paths["setup-mcp.mjs"], ["--remove", "--write"], token, true);
   if (!direct) {
-    keyStore.save({ url: MCP, token, renewedAt: new Date().toISOString(), coupledAt: new Date().toISOString(), account: pairing.account, accountRef: pairing.accountRef, device: device.privateKey.export({ format: "pem", type: "pkcs8" }) });
+    keyStore.save({ url: MCP, token, renewedAt: new Date().toISOString(), coupledAt: new Date().toISOString(), identified: true, profile: computerIds().profile_id, account: pairing.account, accountRef: pairing.accountRef, device: device.privateKey.export({ format: "pem", type: "pkcs8" }) });
     previousNote.erase();
     ensureHome();
     copyFileSync(fileURLToPath(import.meta.url), STABLE);
@@ -720,6 +797,7 @@ function status() {
   try { hook = /log-session|worktrust\.mjs\\?" hook/.test(readFileSync(join(homedir(), ".claude", "settings.json"), "utf8")); } catch { /* none */ }
   say(hook ? "  Session hook: installed" : "  Session hook: not installed");
   if (existsSync(join(homedir(), ".codex"))) { const notify = codexNotify().text ?? ""; say(isOurNotify(notify) ? "  Codex: wakes the session hook" : "  Codex: does not wake the session hook (npx worktrust@latest update asks)"); }
+  if (existsSync(join(homedir(), ".hermes"))) { let text = ""; try { text = readFileSync(join(homedir(), ".hermes", "config.yaml"), "utf8"); } catch { /* none */ } say(/worktrust\.mjs\\?" hook --hermes/.test(text) ? "  Hermes Agent: wakes the session hook" : "  Hermes Agent: does not wake the session hook (npx worktrust@latest update writes it)"); }
   if (antigravityHere()) say(agyHooks()?.worktrust ? "  Antigravity: wakes the session hook" : "  Antigravity: does not wake the session hook (npx worktrust@latest update asks)");
   say(existsSync(join(HOME_DIR, "pinned")) ? "  Counter: from the package, pinned" : existsSync(join(HOME_DIR, "count-behaviour.mjs")) ? "  Counter: follows the site" : "  Counter: not installed");
 }