worktrust 0.6.10 → 0.6.12

package/README.md

@@ -36,7 +36,9 @@ curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
    this computer and asks `Send these as history? [y/N]`. Enter sends nothing. What goes is hours
    and tokens per day, never text, and WorkTrust shows it as earlier work, never as verified hours.
    Nothing from before the coupling is ever sent without that yes: the session hook starts at the
-   moment of coupling.
+   moment of coupling. Beside the seconds, each day says what they were (the model answering, tools
+   running, your own turns, pauses) and what the session's subagents did on their own clocks, as
+   counts; a subagent's hour is shown as an agent-hour and never as one of yours.
 5. **Codex only if you say yes.** With Codex on this computer it asks `Let Codex wake the session
    hook? [y/N]` and, on a yes, sets the one `notify` line in `~/.codex/config.toml` (the file is
    kept as `config.toml.worktrust-backup` first). Another program's `notify` is never replaced.
@@ -62,6 +64,12 @@ curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
    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)
@@ -94,7 +102,7 @@ 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, Hermes Agent, Goose, OpenCode, OpenClaw). 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. |
+| **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. |

package/log-session.mjs

@@ -129,6 +129,14 @@ const MIN_SECONDS = 60;
  * guessing where one piece of work ended and the next began.
  */
 const MAX_SECONDS = 28800;
+/** The door's ceilings for the layers (a day) and for a day's subagents: the same bounds its columns check. */
+const DAY_SECONDS = 86400;
+/** A tool gap is tool time up to thirty minutes (proposed, owner 2026-10-06); past that it is a wait, counted as idle. */
+const TOOL_CAP = 1800;
+/** Tools whose result waits for the person: the gap to it is the person's time. Names only; nothing of the call is read. */
+const WAITS_FOR_PERSON = new Set(["AskUserQuestion", "ExitPlanMode"]);
+const AGENT_RUNS_MAX = 10000;
+const AGENT_SECONDS_MAX = 2592000;
 
 /**
  * WHEN THE HOOK RUNS. SessionEnd alone was a bet that sessions end, and a session that stays open
@@ -202,7 +210,7 @@ const excluded = (path) => excludes.some((text) => text && path.includes(text));
  */
 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 { DATABASE_SESSION = /(?!)/, databaseLines = () => null, databaseSessions = function* () {} } = (await import("./session-databases.mjs").catch(() => null)) ?? {};
-const DATABASE_CLIENTS = ["hermes", "goose", "opencode", "openclaw"]; // the registry's keys, the name each line carries
+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) {
@@ -332,7 +340,7 @@ function stretchesOf(file, since) {
     const at = Date.parse(line.timestamp);
     if (!Number.isFinite(at)) continue;
     if (since && at <= since) continue;
-    messages.push({ at, type: line.type, usage: line.message?.usage ?? null, model: line.message?.model ?? null, meta: line.isMeta === true, content: line.message?.content ?? null });
+    messages.push(messageOf(line, at));
   }
   if (messages.length === 0) return [];
   messages.sort((a, b) => a.at - b.at);
@@ -342,9 +350,77 @@ 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(([day, ofDay]) => { const stretch = measure(cwd, ofDay); return stretch && { ...stretch, ref: stretchRef(file, day), steered }; }).filter(Boolean);
+  const agents = agentsByDay(file, since);
+  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, agents: agents.get(day) ?? null }; }).filter(Boolean);
 }
 
+/** One transcript line as the measure reads it: the clock, the role, what KIND of message it is (for the layers), its counts. */
+const messageOf = (line, at) => {
+  const content = line.message?.content ?? null;
+  const blocks = Array.isArray(content) ? content : [];
+  return {
+    at, type: line.type, usage: line.message?.usage ?? null, model: line.message?.model ?? null, meta: line.isMeta === true, content,
+    // A tool's answer comes back on the user role; a line a reader marks `agentic` is an agent run (Copilot's asked → completed).
+    kind: line.type === "assistant" ? "assistant" : blocks.some((block) => block && block.type === "tool_result") ? "tool_result" : "user",
+    toolUse: line.type === "assistant" && blocks.some((block) => block && block.type === "tool_use"),
+    // A tool that waits for the PERSON (a question, a plan to approve): the gap to its result is the person's, not the tool's. The name is read, never the input.
+    waitsForPerson: line.type === "assistant" && blocks.some((block) => block && block.type === "tool_use" && WAITS_FOR_PERSON.has(String(block.name))),
+    agentic: line.agentic === true,
+  };
+};
+
+/**
+ * SUBAGENTS AS AGENT TIME, NEVER AS HOURS (owner, 2026-10-06). Claude Code writes each subagent's transcript beside its
+ * session (`<session>/subagents/*.jsonl`: 279 of them beside 48 sessions on the computer this was built on), and the
+ * sweep read only the sessions, so delegated work was invisible. Now each run is read for its clocks and sent as
+ * METADATA beside the parent's day: how many runs started that day, their own measured seconds (the same gap rule, the
+ * same cap), and how many were open at once at the busiest moment. None of it enters `seconds`: four agents working an
+ * hour are four agent-hours and one hour of the person's, and the record says which is which. Only Claude Code keeps
+ * subagents this way; every other client answers an empty map.
+ */
+function subagentFiles(file) {
+  if (!/\.jsonl$/.test(String(file)) || CODEX_ROLLOUT.test(file) || ANTIGRAVITY_TRANSCRIPT.test(file) || DATABASE_SESSION.test(file)) return [];
+  const dir = join(String(file).replace(/\.jsonl$/, ""), "subagents");
+  try { return readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => join(dir, name)); } catch { return []; }
+}
+function agentsByDay(file, since) {
+  const byDay = new Map();
+  for (const sub of subagentFiles(file)) {
+    const lines = parsedLines(sub);
+    if (!lines) continue;
+    const stamps = [];
+    let started = Infinity;
+    for (const line of lines) {
+      if (!line.timestamp || (line.type !== "user" && line.type !== "assistant")) continue;
+      const at = Date.parse(line.timestamp);
+      if (!Number.isFinite(at)) continue;
+      started = Math.min(started, at);
+      if (!(since && at <= since)) stamps.push(at);
+    }
+    // A RUN IS COUNTED ONCE, on the side of the watermark where it STARTED (review, 2026-10-06): a run that straddles the
+    // watermark was sent with the day it began and is not a second run on the next sweep; what it did after the
+    // watermark stays unsent, which is the safe direction.
+    if (stamps.length === 0 || (since && started <= since)) continue;
+    stamps.sort((a, b) => a - b);
+    // A run is counted on the day it started; its seconds go with it, the same rule as the parent's.
+    const day = new Date(stamps[0]).toISOString().slice(0, 10);
+    let seconds = 0;
+    for (let i = 1; i < stamps.length; i += 1) seconds += Math.min(IDLE_CAP, Math.round((stamps[i] - stamps[i - 1]) / 1000));
+    if (!byDay.has(day)) byDay.set(day, { runs: 0, seconds: 0, spans: [] });
+    const entry = byDay.get(day);
+    entry.runs += 1; entry.seconds += seconds; entry.spans.push([stamps[0], stamps[stamps.length - 1]]);
+  }
+  for (const entry of byDay.values()) entry.peak = peakOf(entry.spans);
+  return byDay;
+}
+/** The most spans open at one instant; a span that ends where another starts does not overlap it. */
+const peakOf = (spans) => {
+  const events = spans.flatMap(([from, to]) => [[from, 1], [to, -1]]).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  let open = 0, peak = 0;
+  for (const [, delta] of events) { open += delta; peak = Math.max(peak, open); }
+  return peak;
+};
+
 /**
  * IS THIS A HUMAN TURN? (2026-09-20)
  *
@@ -387,7 +463,35 @@ function measure(cwd, messages) {
   }
   const model = [...models.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
   const tokens = tokensOf(messages);
-  return { cwd, seconds: measured, ...tokens, exchanges, model, from: messages[0].at, to: messages[messages.length - 1].at };
+  return { cwd, seconds: measured, layers: measured !== null ? timeLayers(messages) : null, ...tokens, exchanges, model, from: messages[0].at, to: messages[messages.length - 1].at };
+}
+
+/**
+ * HOW THE SECONDS WERE SPENT (owner, 2026-10-06: "observed time → AI active → agent-directed → verified work activity").
+ * `seconds` keeps its exact meaning above; this reads the same gaps a second time and says what each one WAS, by the
+ * message that ends it: the model's message (model time, capped as before), a tool's result or an agent run (tool time,
+ * NOT capped at five minutes, because a test suite that ran twenty minutes was twenty minutes of the agent's work; bounded
+ * by the stretch's own ceiling), or the person's next turn (human time, capped). What a cap cut off is idle, counted as
+ * idle and never as work. The four sum to the stretch's span, so nothing is hidden and nothing is double-counted.
+ */
+function timeLayers(messages) {
+  const split = { model: 0, tool: 0, human: 0, idle: 0 };
+  for (let i = 1; i < messages.length; i += 1) {
+    const gap = Math.max(0, Math.round((messages[i].at - messages[i - 1].at) / 1000));
+    const next = messages[i], prev = messages[i - 1];
+    // WAITS FOR THE PERSON ARE NOT TOOL TIME (review, 2026-10-06). A tool's result arrives when the tool is done, or when the
+    // person answered a question, approved a plan, or sat on a permission prompt. The first two are named by the tool and
+    // counted as human time; the third is invisible in the transcript, so a tool gap is counted as tool time only up to
+    // TOOL_CAP, and the rest as idle: a tool runs minutes, a person away from the keyboard does not.
+    const tool = (next.kind === "tool_result" || next.agentic || (prev.toolUse && next.kind === "assistant")) && !prev.waitsForPerson;
+    // ONE DEFINITION OF A HUMAN TURN (review, 2026-10-06): the same `isHumanTurn` that counts `exchanges`; a user line that
+    // is not one (a meta line the client injected, a textless line) is the loop's own and counts as model time.
+    const human = !tool && ((prev.waitsForPerson && next.kind === "tool_result") || (next.kind === "user" && !next.meta && isHumanTurn(next.content)));
+    const counted = Math.min(tool ? TOOL_CAP : IDLE_CAP, gap);
+    split[tool ? "tool" : human ? "human" : "model"] += counted;
+    split.idle += gap - counted;
+  }
+  return split;
 }
 
 /**
@@ -455,6 +559,10 @@ function payloadFor(stretch) {
     ...(repo ? { repo } : {}),
     ...(touched.shas.length > 0 ? { commits: touched.shas.slice(0, 50) } : {}),
     ...(stretch.ref ? { stretch_ref: stretch.ref } : {}), ...(stretch.steered ? { steered_from: stretch.steered } : {}),
+    // THE LAYERS (2026-10-06), only on a measured stretch, each bounded by a day: what the seconds were. `seconds` above is untouched.
+    ...(stretch.seconds !== null && stretch.layers ? { model_seconds: Math.min(DAY_SECONDS, stretch.layers.model), tool_seconds: Math.min(DAY_SECONDS, stretch.layers.tool), human_seconds: Math.min(DAY_SECONDS, stretch.layers.human), idle_seconds: Math.min(DAY_SECONDS, stretch.layers.idle) } : {}),
+    // THE SUBAGENTS, as agent metadata beside the day: runs, their own seconds, the peak open at once. Never in `seconds`.
+    ...(stretch.agents && stretch.agents.runs > 0 ? { agent_runs: Math.min(AGENT_RUNS_MAX, stretch.agents.runs), agent_seconds: Math.min(AGENT_SECONDS_MAX, stretch.agents.seconds), agent_peak: Math.min(AGENT_RUNS_MAX, stretch.agents.peak) } : {}),
     at: new Date(stretch.to).toISOString(),
   };
 }
@@ -540,8 +648,9 @@ function historyEntries(floor = null) {
       if (!Number.isFinite(at)) continue;
       const day = new Date(at).toISOString().slice(0, 10);
       if (!byDay.has(day)) byDay.set(day, []);
-      byDay.get(day).push({ at, type: line.type, usage: line.message?.usage ?? null, model: line.message?.model ?? null, meta: line.isMeta === true, content: line.message?.content ?? null });
+      byDay.get(day).push(messageOf(line, at));
     }
+    const agents = agentsByDay(file, null);
     for (const [day, messages] of byDay) {
       if (messages.length === 0) continue;
       messages.sort((a, b) => a.at - b.at);
@@ -550,20 +659,8 @@ function historyEntries(floor = null) {
       const last = messages[messages.length - 1].at;
       // The live window belongs to the hook: a stretch that log_work may still report is not history.
       if (Date.now() - last < WINDOW_HOURS * 3600_000) continue;
-      let seconds = 0;
-      for (let i = 1; i < messages.length; i += 1) seconds += Math.min(IDLE_CAP, Math.round((messages[i].at - messages[i - 1].at) / 1000));
-      const models = new Map();
-      let exchanges = 0;
-      for (const message of messages) {
-        if (message.type === "user" && !message.meta && isHumanTurn(message.content)) exchanges += 1;
-        if (message.model) models.set(message.model, (models.get(message.model) ?? 0) + 1);
-      }
-      const { tokensIn, tokensOut, cacheRead, cacheWrite, shapeKnown } = tokensOf(messages);
-      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, ref: stretchRef(file, day), steered,
-      });
+      // The same measure as a live day (seconds, layers, tokens, turns, model); history differs only in the door it goes through.
+      const entry = payloadFor({ ...measure(cwd, messages), ref: stretchRef(file, day), steered, agents: agents.get(day) ?? null });
       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(":")));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "description": "Couple this computer to WorkTrust: approve a code in your browser, and every AI app here reports what you built. Metadata only, no dependencies.",
   "type": "module",
   "bin": {

package/session-databases.mjs

@@ -8,7 +8,7 @@
  * 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 { readdirSync, statSync } from "node:fs";
+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";
@@ -288,6 +288,145 @@ export function openclawLines(pseudo) {
 }
 // ── 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, in `seconds`; in the layers it is the agent's run, whole (the assistant line says `agentic`).
+ */
+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 } } : {};
+    // `agentic` (owner, 2026-10-06): the request's own run, asked → completed, is the agent's time; the hook files that gap as tool time, uncapped.
+    lines.push({ type: "assistant", timestamp: new Date(done).toISOString(), agentic: true, 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 = {
@@ -295,6 +434,8 @@ const DATABASE_CLIENTS = {
   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. */

package/worktrust.mjs

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