reflex-skills 0.5.1 → 0.5.2

package/README.md

@@ -56,6 +56,7 @@ alias reflex="node $PWD/apps/cli/dist/reflex.js"
 | `improve [skill]` | For skills you already have: lists them with the sessions that loaded each; with a name, compares the skill with those sessions and proposes an edit (asks before reading the skill and before changing it; keeps a backup). `--file`, `--yes` |
 | `agents` | Sessions that launched agents (Cursor): how many, which kinds, and how many tool calls the agents made |
 | `handbook` | How work is done in the current repository, learned from past sessions: test, build and lint commands that worked (and ones that kept failing), and corrections you repeated, with the situation they came up in and the sessions behind each. `show <id>`, `ask "<question>"`, `export` (Markdown for a teammate, no request text), `--project`, `--all`, `--json`. Read-only, so agents can call it |
+| `cursor-usage [on\|off]` | Record Cursor's token counts locally through a Cursor hook, since Cursor saves none in its transcripts. `on` adds Reflex's hook to `~/.cursor/hooks.json` (asks first, keeps your other hooks, backs the file up); `off` removes it |
 | `stats` | Counts from local data |
 | `reset` | Delete Reflex's own data (not installed skills or the model) |
 | `model [status\|fetch\|use\|remove]` | Optional local embedding model for matching requests by meaning. `fetch` downloads bge-m3 (multilingual, 587 MB); `fetch --light` the English-only all-MiniLM-L6-v2 (23 MB); `use <name>` switches between installed ones |
@@ -76,9 +77,9 @@ tool, model and project, the most expensive sessions, what caching saved), gener
 suggestions waiting for review, every repeated workflow with the evidence behind it, router
 suggestions (which model was cheapest and about as reliable, per kind of task), and a search over
 each session's opening request and steps. Enter reopens a Claude Code or Codex session, or opens a
-Cursor chat's workspace in Cursor. Cursor records no tokens, so its sessions have no cost; if you
-allow it, Reflex reads which model each Cursor chat used and Tokens counts Cursor sessions per
-model. Usage
+Cursor chat's workspace in Cursor. Cursor saves no tokens in its transcripts, so its sessions have
+no cost unless you turn on `reflex cursor-usage` (below); if you allow it, Reflex reads which model
+each Cursor chat used and Tokens counts Cursor sessions per model. Usage
 limits are not recorded, so that block says `not measured yet`. Run `reflex scan` again (or press
 `r`) after upgrading: costs need the model of each session, which older scans did not store.
 
@@ -184,7 +185,8 @@ both sides have at least 3 runs, and never predicts savings in advance.
 
 - Tokens are whole-session totals as Claude Code and Codex record them, cache reads included, so
   other work in the same session counts too.
-- Cursor doesn't record tokens. Cursor runs count tool calls only.
+- Cursor saves no tokens in its transcripts. Cursor runs count tool calls only, unless
+  `reflex cursor-usage` was on during them.
 - The skill's own cost is shown as an estimate from its file size (4 characters per token).
 
 ## Routing tasks to models
@@ -250,6 +252,14 @@ Threat model and mitigations: [docs/security.md](docs/security.md).
 | Codex | `$CODEX_HOME/sessions/YYYY/MM/DD/rollout-*.jsonl` | `~/.codex/skills/<name>/SKILL.md` | Parser follows the Codex protocol types and is tested on fixtures; not yet run against real rollouts or a live Codex session |
 | Cursor | `~/.cursor/projects/*/agent-transcripts/*/*.jsonl` | `~/.cursor/skills/<name>/SKILL.md` | Parser tested on fixtures and on real agent transcripts. Cursor doesn't record tool results, so pass/fail outcomes aren't available for its sessions |
 
+**Cursor token usage.** Cursor's transcripts and app database have no token counts (every
+`tokenCount` is 0), but Cursor passes each agent turn's counts to its hooks. `reflex cursor-usage on`
+adds one hook (`stop`, with `afterAgentResponse` as fallback) that appends the chat and turn ids, the
+model and the four token counts to `~/.reflex/cursor-usage.jsonl`; never the prompt or the answer, no
+network. The chat id is the transcript's file name, so `reflex scan` attaches those counts to each
+Cursor chat and prices them like other sessions. Only turns from while the hook is on are counted;
+Cursor's command-line agent in `-p` mode sends no end-of-turn hook. Not available on Windows yet.
+
 **Agents a session launched.** When a Cursor chat launches agents (its `Task` / `Subagent` tool),
 Reflex records each one (kind, model, background or not, its short description) and reads the
 agents' transcripts (`<chat>/subagents/*.jsonl`). Their commands, files and tool calls count toward

package/dist/reflex.js

@@ -3461,12 +3461,12 @@ var require_src = __commonJS({
         else if (y3 > 0) ret += `${CSI}${y3}B`;
         return ret;
       },
-      up: (count2 = 1) => `${CSI}${count2}A`,
-      down: (count2 = 1) => `${CSI}${count2}B`,
-      forward: (count2 = 1) => `${CSI}${count2}C`,
-      backward: (count2 = 1) => `${CSI}${count2}D`,
-      nextLine: (count2 = 1) => `${CSI}E`.repeat(count2),
-      prevLine: (count2 = 1) => `${CSI}F`.repeat(count2),
+      up: (count3 = 1) => `${CSI}${count3}A`,
+      down: (count3 = 1) => `${CSI}${count3}B`,
+      forward: (count3 = 1) => `${CSI}${count3}C`,
+      backward: (count3 = 1) => `${CSI}${count3}D`,
+      nextLine: (count3 = 1) => `${CSI}E`.repeat(count3),
+      prevLine: (count3 = 1) => `${CSI}F`.repeat(count3),
       left: `${CSI}G`,
       hide: `${CSI}?25l`,
       show: `${CSI}?25h`,
@@ -3474,21 +3474,21 @@ var require_src = __commonJS({
       restore: `${ESC}8`
     };
     var scroll = {
-      up: (count2 = 1) => `${CSI}S`.repeat(count2),
-      down: (count2 = 1) => `${CSI}T`.repeat(count2)
+      up: (count3 = 1) => `${CSI}S`.repeat(count3),
+      down: (count3 = 1) => `${CSI}T`.repeat(count3)
     };
     var erase = {
       screen: `${CSI}2J`,
-      up: (count2 = 1) => `${CSI}1J`.repeat(count2),
-      down: (count2 = 1) => `${CSI}J`.repeat(count2),
+      up: (count3 = 1) => `${CSI}1J`.repeat(count3),
+      down: (count3 = 1) => `${CSI}J`.repeat(count3),
       line: `${CSI}2K`,
       lineEnd: `${CSI}K`,
       lineStart: `${CSI}1K`,
-      lines(count2) {
+      lines(count3) {
         let clear = "";
-        for (let i = 0; i < count2; i++)
-          clear += this.line + (i < count2 - 1 ? cursor.up() : "");
-        if (count2)
+        for (let i = 0; i < count3; i++)
+          clear += this.line + (i < count3 - 1 ? cursor.up() : "");
+        if (count3)
           clear += cursor.left;
         return clear;
       }
@@ -5242,9 +5242,9 @@ function assertNever(_x) {
 }
 function assert(_3) {
 }
-function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
-  const values = Object.entries(entries).filter(([k3, _3]) => numericValues.indexOf(+k3) === -1).map(([_3, v2]) => v2);
+function getEnumValues(entries2) {
+  const numericValues = Object.values(entries2).filter((v2) => typeof v2 === "number");
+  const values = Object.entries(entries2).filter(([k3, _3]) => numericValues.indexOf(+k3) === -1).map(([_3, v2]) => v2);
   return values;
 }
 function joinValues(array2, separator = "|") {
@@ -5781,14 +5781,14 @@ function codePointLength(str3) {
   const units = str3.length;
   if (!highSurrogate.test(str3))
     return units;
-  let count2 = units;
+  let count3 = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str3.charCodeAt(i) & 64512) === 55296 && (str3.charCodeAt(i + 1) & 64512) === 56320) {
-      count2--;
+      count3--;
       i++;
     }
   }
-  return count2;
+  return count3;
 }
 function getLengthableOrigin(input2) {
   if (Array.isArray(input2))
@@ -6564,8 +6564,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter3) => {
-  const escapedDelim = escapeRegex(delimiter3 ?? ":");
+var mac = (delimiter4) => {
+  const escapedDelim = escapeRegex(delimiter4 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -7067,16 +7067,16 @@ var $ZodCheckProperties = /* @__PURE__ */ $constructor("$ZodCheckProperties", (i
   hide(inst, Symbol.iterator, function* () {
     yield inst;
   });
-  let entries;
+  let entries2;
   inst._zod.check = (payload) => {
     if (payload.value == null) {
       payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
       return void 0;
     }
-    entries ?? (entries = Reflect.ownKeys(def.shape).map((key3) => [key3, def.shape[key3]]));
+    entries2 ?? (entries2 = Reflect.ownKeys(def.shape).map((key3) => [key3, def.shape[key3]]));
     const input2 = payload.value;
     let proms;
-    for (const [key3, schema] of entries) {
+    for (const [key3, schema] of entries2) {
       const result = schema._zod.run({ value: input2[key3], issues: [] }, {});
       if (result instanceof Promise) {
         proms ?? (proms = []);
@@ -10143,8 +10143,8 @@ function az_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getBelarusianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -12791,8 +12791,8 @@ function hu_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count2, one, many) {
-  return Math.abs(count2) === 1 ? one : many;
+function getArmenianPlural(count3, one, many) {
+  return Math.abs(count3) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -15530,8 +15530,8 @@ function ro_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getRussianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -19858,18 +19858,18 @@ function _set(Class2, valueType, params) {
 }
 // @__NO_SIDE_EFFECTS__
 function _enum(Class2, values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
+  const entries2 = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new Class2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...normalizeParams(params)
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _nativeEnum(Class2, entries, params) {
+function _nativeEnum(Class2, entries2, params) {
   return new Class2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...normalizeParams(params)
   });
 }
@@ -22852,17 +22852,17 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   };
 });
 function _enum2(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
+  const entries2 = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new ZodEnum({
     type: "enum",
-    entries,
+    entries: entries2,
     ...util_exports.normalizeParams(params)
   });
 }
-function nativeEnum(entries, params) {
+function nativeEnum(entries2, params) {
   return new ZodEnum({
     type: "enum",
-    entries,
+    entries: entries2,
     ...util_exports.normalizeParams(params)
   });
 }
@@ -24249,7 +24249,7 @@ var RULES = [
     // DATABASE_URL=..., OPENAI_API_KEY="...", export AWS_SECRET_ACCESS_KEY=...
     name: "sensitive-assignment",
     pattern: new RegExp(`\\b(${SENSITIVE_KEY})(\\s*[=:]\\s*)("[^"\\n]*"|'[^'\\n]*'|[^\\s"',;]+)`, "g"),
-    replace: (_m, key3, sep3) => `${key3}${sep3.includes(":") ? ": " : "="}[REDACTED]`
+    replace: (_m, key3, sep4) => `${key3}${sep4.includes(":") ? ": " : "="}[REDACTED]`
   },
   {
     // aws configure set aws_secret_access_key VALUE
@@ -24261,7 +24261,7 @@ var RULES = [
     // password=..., "token": "...", api_key: ...
     name: "credential-field",
     pattern: /(["']?)\b(password|passwd|pwd|pass|secret|token|api[_-]?key|apikey|access[_-]?token|refresh[_-]?token|id[_-]?token|client[_-]?secret|auth[_-]?token|private[_-]?key)\b\1(\s*[=:]\s*)("[^"\n]*"|'[^'\n]*'|[^\s&,;"'}]+)/gi,
-    replace: (_m, q2, key3, sep3) => `${q2}${key3}${q2}${sep3}[REDACTED]`
+    replace: (_m, q2, key3, sep4) => `${q2}${key3}${q2}${sep4}[REDACTED]`
   },
   {
     name: "authorization-header",
@@ -24587,13 +24587,13 @@ function patchedFiles(patch) {
 async function listFiles(dir, ext, depth) {
   const out2 = [];
   async function walk(current, level) {
-    let entries;
+    let entries2;
     try {
-      entries = await readdir(current, { withFileTypes: true });
+      entries2 = await readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
-    for (const entry of entries) {
+    for (const entry of entries2) {
       if (entry.isSymbolicLink()) continue;
       const full = join2(current, entry.name);
       if (level < depth) {
@@ -25157,6 +25157,95 @@ var CursorModelIndex = class {
   }
 };
 
+// ../../packages/adapters/src/cursor-usage.ts
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+var MAX_LOG_BYTES = 64 * 1024 * 1024;
+var ID2 = /^[A-Za-z0-9-]{1,80}$/;
+var MODEL = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,79}$/;
+var CLAUDE = /^(?:claude-)?(?:(\d+(?:[.-]\d+)?)-(opus|sonnet|haiku|fable|mythos)|(opus|sonnet|haiku|fable|mythos)-(\d+(?:[.-]\d+)?))(?:-.*)?$/;
+function cursorModelName(id) {
+  const m2 = id.toLowerCase().match(CLAUDE);
+  if (!m2) return id;
+  const name = `claude-${m2[2] ?? m2[3]}-${(m2[1] ?? m2[4]).replace(".", "-")}`;
+  return priceOf(name) ? name : id;
+}
+function tail(path, max) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    const size2 = fstatSync(fd).size;
+    const start = Math.max(0, size2 - max);
+    const buf = Buffer.alloc(size2 - start);
+    readSync(fd, buf, 0, buf.length, start);
+    const text = buf.toString("utf8");
+    return start ? text.slice(text.indexOf("\n") + 1) : text;
+  } catch {
+    return "";
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+}
+var count = (v2) => typeof v2 === "number" && Number.isFinite(v2) && v2 > 0 ? Math.round(v2) : 0;
+var CursorUsageLog = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  turns;
+  load() {
+    if (this.turns) return this.turns;
+    const turns = /* @__PURE__ */ new Map();
+    this.turns = turns;
+    for (const line2 of tail(this.path, MAX_LOG_BYTES).split("\n")) {
+      let r2;
+      try {
+        r2 = JSON.parse(line2);
+      } catch {
+        continue;
+      }
+      const conv = typeof r2.conversation_id === "string" && ID2.test(r2.conversation_id) ? r2.conversation_id : void 0;
+      const gen = typeof r2.generation_id === "string" && ID2.test(r2.generation_id) ? r2.generation_id : void 0;
+      if (!conv || !gen) continue;
+      const cacheRead = count(r2.cache_read_tokens);
+      const cacheWrite = count(r2.cache_write_tokens);
+      const usage2 = { input: Math.max(0, count(r2.input_tokens) - cacheRead - cacheWrite), output: count(r2.output_tokens), cacheRead, cacheWrite };
+      const turn = {
+        event: r2.event === "stop" ? "stop" : "afterAgentResponse",
+        at: typeof r2.at === "string" ? Date.parse(r2.at) || 0 : 0,
+        model: typeof r2.model === "string" && MODEL.test(r2.model) ? cursorModelName(r2.model) : void 0,
+        usage: usage2
+      };
+      const byGen = turns.get(conv) ?? /* @__PURE__ */ new Map();
+      turns.set(conv, byGen);
+      const prev = byGen.get(gen);
+      if (!prev || turn.event === "stop" || prev.event !== "stop") byGen.set(gen, turn);
+    }
+    return turns;
+  }
+  /** Usage for these conversations, in total and per model. */
+  usageFor(ids) {
+    let usage2;
+    const byModel2 = {};
+    for (const id of ids)
+      for (const t of this.load().get(id)?.values() ?? []) {
+        usage2 = addUsage(usage2, t.usage);
+        if (t.model) byModel2[t.model] = addUsage(byModel2[t.model], t.usage);
+      }
+    return usage2 ? { usage: usage2, byModel: byModel2 } : void 0;
+  }
+  /** How many turns were recorded for these conversations, and when the latest was: part of a chat's identity for the scan cache. */
+  signature(ids) {
+    let turns = 0;
+    let latest = 0;
+    for (const id of ids)
+      for (const t of this.load().get(id)?.values() ?? []) {
+        turns++;
+        latest = Math.max(latest, t.at);
+      }
+    return { turns, latest };
+  }
+};
+
 // ../../packages/adapters/src/cursor.ts
 var CONTROL = /[\x00-\x1f\x7f-\x9f]/g;
 var Block = external_exports.object({
@@ -25232,10 +25321,21 @@ var CursorAdapter = class {
   /** Cursor's app database, for model names. Undefined for a custom transcript folder, which reads only that folder. */
   stateDb;
   models;
-  constructor(root, stateDb) {
+  /** Token counts recorded by Reflex's Cursor hook, when it was turned on. */
+  usage;
+  constructor(root, stateDb, opts = {}) {
     this.root = root ?? process.env.REFLEX_CURSOR_DIR ?? join6(homedir6(), ".cursor", "projects");
     const custom2 = root ?? process.env.REFLEX_CURSOR_DIR;
     this.stateDb = stateDb ?? process.env.REFLEX_CURSOR_STATE_DB ?? (custom2 ? void 0 : defaultCursorStateDb());
+    if (opts.usageLog) this.usage = new CursorUsageLog(opts.usageLog);
+  }
+  /**
+   * The conversation ids whose recorded turns belong to this chat: the chat's own. Agents it
+   * launched may report their own turns too, and whether the chat's totals already include them
+   * is not known yet, so they are left out rather than possibly counted twice.
+   */
+  conversationIds(chatFile) {
+    return [basename4(chatFile, ".jsonl")];
   }
   /** Whether the user allowed reading model names from Cursor's app database in this scan. */
   get readsModels() {
@@ -25293,6 +25393,11 @@ var CursorAdapter = class {
           f.identity.ctimeMs = Math.max(f.identity.ctimeMs, agent.identity.ctimeMs);
         }
       }
+      if (this.usage) {
+        const sig = this.usage.signature(this.conversationIds(f.path));
+        f.sizeBytes += sig.turns;
+        if (f.identity && sig.latest) f.identity.ctimeMs = Math.max(f.identity.ctimeMs, sig.latest);
+      }
       if (f.modifiedAt >= cutoff) out2.push(f);
     }
     return out2;
@@ -25337,6 +25442,11 @@ var CursorAdapter = class {
     }
     if (delegated.length) b3.events.splice(firstSpawn ?? b3.events.length, 0, ...delegated.slice(0, Math.max(0, MAX_EVENTS_PER_SESSION - b3.events.length)));
     b3.touch(file2.modifiedAt.toISOString());
+    const recorded2 = this.usage?.usageFor(this.conversationIds(file2.path));
+    if (recorded2) {
+      b3.usage = recorded2.usage;
+      if (Object.keys(recorded2.byModel).length) b3.usageByModel = recorded2.byModel;
+    }
     const session = b3.build();
     if (spawned.length || transcripts) session.agents = { spawned, transcripts };
     if (this.models) session.models = this.models.modelsFor(b3.nativeId);
@@ -25989,14 +26099,14 @@ function buildTfIdf(docs, weights) {
   for (const doc of docs) for (const term of new Set(doc)) df.set(term, (df.get(term) ?? 0) + 1);
   const n = docs.length;
   const idf = /* @__PURE__ */ new Map();
-  for (const [term, count2] of df) idf.set(term, Math.log((n + 1) / (count2 + 1)) + 1);
+  for (const [term, count3] of df) idf.set(term, Math.log((n + 1) / (count3 + 1)) + 1);
   const vectors = docs.map((doc) => {
     const tf = /* @__PURE__ */ new Map();
     for (const term of doc) tf.set(term, (tf.get(term) ?? 0) + 1);
     const v2 = /* @__PURE__ */ new Map();
     let norm = 0;
-    for (const [term, count2] of tf) {
-      const w2 = (1 + Math.log(count2)) * (idf.get(term) ?? 1) * (weights?.get(term) ?? 1);
+    for (const [term, count3] of tf) {
+      const w2 = (1 + Math.log(count3)) * (idf.get(term) ?? 1) * (weights?.get(term) ?? 1);
       v2.set(term, w2);
       norm += w2 * w2;
     }
@@ -27008,8 +27118,8 @@ function analyze(traces, opts = {}) {
     const repoNames = [...new Set(group.map((g2) => g2.primary.projectName).filter((x2) => !!x2))].sort();
     const sources = {};
     for (const id of SOURCE_IDS) {
-      const count2 = group.filter((g2) => g2.primary.source === id).length;
-      if (count2) sources[id] = count2;
+      const count3 = group.filter((g2) => g2.primary.source === id).length;
+      if (count3) sources[id] = count3;
     }
     const dates = group.map((g2) => g2.primary.startedAt).filter((d3) => !!d3).sort();
     const verifiedRate = group.filter((g2) => g2.primary.outcome.verified).length / group.length;
@@ -27437,12 +27547,12 @@ function scopeOf(group) {
   return hash2 ? { name: group[0].primary.projectName, hash: hash2 } : void 0;
 }
 function situation(group, others) {
-  const count2 = (xs, cat) => xs.filter((i) => i.primary.fileCategories.includes(cat)).length;
+  const count3 = (xs, cat) => xs.filter((i) => i.primary.fileCategories.includes(cat)).length;
   let best;
   for (const s of SITUATIONS) {
-    const inside = count2(group, s.category) / group.length;
+    const inside = count3(group, s.category) / group.length;
     if (inside < WHEN_SHARE) continue;
-    const lift = inside / ((count2(others, s.category) + 0.5) / (others.length + 1));
+    const lift = inside / ((count3(others, s.category) + 0.5) / (others.length + 1));
     if (lift >= WHEN_LIFT && (!best || lift > best.lift)) best = { when: s.when, lift };
   }
   return best?.when;
@@ -28274,7 +28384,10 @@ var paths = {
   home: reflexHome,
   db: () => join13(reflexHome(), "reflex.db"),
   skills: () => join13(reflexHome(), "skills"),
-  models: () => join13(reflexHome(), "models")
+  models: () => join13(reflexHome(), "models"),
+  /** Token counts Reflex's Cursor hook records (`reflex cursor-usage on`). */
+  cursorUsage: () => join13(reflexHome(), "cursor-usage.jsonl"),
+  hooks: () => join13(reflexHome(), "hooks")
 };
 
 // ../../packages/storage/src/db.ts
@@ -28636,11 +28749,11 @@ var Store = class {
     }
     return out2;
   }
-  saveEmbeddings(model2, entries) {
+  saveEmbeddings(model2, entries2) {
     const put = this.db.prepare("INSERT OR REPLACE INTO embeddings (key, model, vector) VALUES (?,?,COALESCE(?, zeroblob(0)))");
     this.db.exec("BEGIN IMMEDIATE");
     try {
-      for (const [key3, v2] of entries) put.run(key3, model2, new Uint8Array(v2.buffer, v2.byteOffset, v2.byteLength));
+      for (const [key3, v2] of entries2) put.run(key3, model2, new Uint8Array(v2.buffer, v2.byteOffset, v2.byteLength));
       this.db.exec("COMMIT");
     } catch (err) {
       this.db.exec("ROLLBACK");
@@ -30767,13 +30880,13 @@ import { join as join17 } from "node:path";
 async function skillFiles() {
   const out2 = [];
   for (const t of await detectTargets()) {
-    let entries;
+    let entries2;
     try {
-      entries = await readdir3(t.skillsDir, { withFileTypes: true });
+      entries2 = await readdir3(t.skillsDir, { withFileTypes: true });
     } catch {
       continue;
     }
-    for (const e2 of entries) {
+    for (const e2 of entries2) {
       if (!(e2.isDirectory() || e2.isSymbolicLink()) || !OWN_SKILL_NAME.test(e2.name)) continue;
       const entry = join17(t.skillsDir, e2.name);
       try {
@@ -30839,7 +30952,7 @@ function chooseAdapters(opts) {
     if (opts.cursorDir) adapters.push(new CursorAdapter(opts.cursorDir));
     return { adapters: only(adapters), mode: "custom" };
   }
-  return { adapters: only([new ClaudeCodeAdapter(), new CodexAdapter(), new CursorAdapter()]), mode: "local" };
+  return { adapters: only([new ClaudeCodeAdapter(), new CodexAdapter(), new CursorAdapter(void 0, void 0, { usageLog: paths.cursorUsage() })]), mode: "local" };
 }
 async function scan(opts) {
   const { adapters, mode } = chooseAdapters(opts);
@@ -31525,14 +31638,168 @@ async function reject(ref) {
 // src/commands/misc.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { readdir as readdir4, rm as rm3, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir11 } from "node:os";
+import { join as join20 } from "node:path";
+
+// src/cursor-hook.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { readFile as readFile7 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { join as join19 } from "node:path";
-var conductorRoot = () => process.env.REFLEX_CONDUCTOR_DIR ?? join19(homedir10(), "conductor", "workspaces");
+import { delimiter, join as join19, sep as sep3 } from "node:path";
+var HOOK_EVENTS = ["stop", "afterAgentResponse"];
+var SCRIPT_NAME = "cursor-usage.mjs";
+function assertHookSupported(platform2 = process.platform) {
+  if (platform2 === "win32") throw new Error("reflex cursor-usage isn't available on Windows yet: Reflex can't yet write a hook command Cursor runs there.");
+}
+var cursorHooksFile = () => process.env.REFLEX_CURSOR_HOOKS_FILE ?? join19(homedir10(), ".cursor", "hooks.json");
+var hookScript = () => join19(paths.hooks(), SCRIPT_NAME);
+function hookSource(logPath) {
+  return `// Written by Reflex (reflex cursor-usage on). Records token counts per Cursor agent turn; never text.
+import { appendFileSync } from "node:fs";
+const LOG = ${JSON.stringify(logPath)};
+const ID = /^[A-Za-z0-9-]{1,80}$/;
+const MODEL = /^[A-Za-z0-9][A-Za-z0-9._:\\/-]{0,79}$/;
+const id = (v) => (typeof v === "string" && ID.test(v) ? v : undefined);
+const model = (v) => (typeof v === "string" && MODEL.test(v) ? v : undefined);
+const n = (v) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.round(v) : undefined);
+let raw = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (c) => { if (raw.length < 8000000) raw += c; });
+process.stdin.on("end", () => {
+  try {
+    const p = JSON.parse(raw);
+    const event = p.hook_event_name;
+    const rec = {
+      v: 1,
+      at: new Date().toISOString(),
+      event,
+      conversation_id: id(p.conversation_id),
+      generation_id: id(p.generation_id),
+      model: model(p.model_id) ?? model(p.model),
+      input_tokens: n(p.input_tokens),
+      output_tokens: n(p.output_tokens),
+      cache_read_tokens: n(p.cache_read_tokens),
+      cache_write_tokens: n(p.cache_write_tokens),
+    };
+    const counted = rec.input_tokens !== undefined || rec.output_tokens !== undefined;
+    if ((event === "stop" || event === "afterAgentResponse") && rec.conversation_id && rec.generation_id && counted) {
+      appendFileSync(LOG, JSON.stringify(rec) + "\\n", { mode: 0o600 });
+    }
+  } catch {}
+  process.stdout.write("{}");
+});
+`;
+}
+function stableNode(execPath = process.execPath, pathEnv = process.env.PATH ?? "") {
+  let real;
+  try {
+    real = realpathSync2(execPath);
+  } catch {
+    return execPath;
+  }
+  for (const dir of pathEnv.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join19(dir, "node");
+    try {
+      if (candidate !== execPath && realpathSync2(candidate) === real) return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return execPath;
+}
+function hookCommand(node2 = stableNode(), script = hookScript()) {
+  for (const p3 of [node2, script]) if (p3.includes("'")) throw new Error(`Reflex can't quote the path ${p3} for a hook command.`);
+  return `'${node2}' '${script}'`;
+}
+var ours = (e2) => typeof e2?.command === "string" && e2.command.endsWith(`${sep3}hooks${sep3}${SCRIPT_NAME}'`);
+function entries(hooks, event, file2) {
+  const v2 = hooks[event];
+  if (v2 === void 0) return [];
+  if (!Array.isArray(v2)) throw new Error(`${file2} has "${event}" that isn't a list; Reflex won't overwrite it. Fix it, then run this again.`);
+  return [...v2];
+}
+async function readHooks(file2) {
+  if (await isSymlink(file2)) throw new Error(`${file2} is a symlink; Reflex won't write through it. Add the hook entry yourself (see reflex cursor-usage status).`);
+  if (!await pathExists(file2)) return { data: { version: 1, hooks: {} } };
+  const raw = await readFile7(file2, "utf8");
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    throw new Error(`${file2} is not valid JSON; Reflex won't overwrite it. Fix it, then run this again.`);
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error(`${file2} is not a hooks object; Reflex won't overwrite it.`);
+  return { data, raw };
+}
+async function hookStatus(file2 = cursorHooksFile()) {
+  try {
+    const { data } = await readHooks(file2);
+    const hooks = data.hooks ?? {};
+    return { events: HOOK_EVENTS.filter((e2) => Array.isArray(hooks[e2]) && hooks[e2].some(ours)) };
+  } catch (e2) {
+    return { events: [], error: e2 instanceof Error ? e2.message : String(e2) };
+  }
+}
+async function writeHooks(file2, data, raw) {
+  let backup;
+  if (raw !== void 0) {
+    const dir = join19(paths.home(), "backups");
+    await ensureDir(paths.home(), 448);
+    await ensureDir(dir, 448);
+    backup = join19(dir, `cursor-hooks-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`);
+    await writeNewFile(backup, raw, 384);
+  }
+  await ensureDir(join19(file2, ".."), 493);
+  await replaceOwnedFile(file2, JSON.stringify(data, null, 2) + "\n", 420);
+  return backup;
+}
+async function installHook(file2 = cursorHooksFile()) {
+  assertHookSupported();
+  await ensureDir(paths.home(), 448);
+  await ensureDir(paths.hooks(), 448);
+  await replaceOwnedFile(hookScript(), hookSource(paths.cursorUsage()), 448);
+  const { data, raw } = await readHooks(file2);
+  const hooks = { ...data.hooks ?? {} };
+  const command = hookCommand();
+  const added = [];
+  for (const event of HOOK_EVENTS) {
+    const list = entries(hooks, event, file2);
+    if (list.some(ours)) {
+      hooks[event] = list.map((e2) => ours(e2) ? { ...e2, command } : e2);
+      continue;
+    }
+    hooks[event] = [...list, { command, timeout: 5 }];
+    added.push(event);
+  }
+  const backup = await writeHooks(file2, { ...data, version: data.version ?? 1, hooks }, raw);
+  return { added, backup };
+}
+async function removeHook(file2 = cursorHooksFile()) {
+  if (!await pathExists(file2)) return { removed: [] };
+  const { data, raw } = await readHooks(file2);
+  const hooks = { ...data.hooks ?? {} };
+  const removed = [];
+  for (const event of HOOK_EVENTS) {
+    const list = entries(hooks, event, file2);
+    const kept = list.filter((e2) => !ours(e2));
+    if (kept.length === list.length) continue;
+    removed.push(event);
+    if (kept.length) hooks[event] = kept;
+    else delete hooks[event];
+  }
+  if (!removed.length) return { removed };
+  const backup = await writeHooks(file2, { ...data, hooks }, raw);
+  return { removed, backup };
+}
+
+// src/commands/misc.ts
+var conductorRoot = () => process.env.REFLEX_CONDUCTOR_DIR ?? join20(homedir11(), "conductor", "workspaces");
 async function conductorWorkspaces() {
   const dir = conductorRoot();
   try {
-    const entries = await readdir4(dir, { withFileTypes: true });
-    return { dir, repos: entries.filter((e2) => e2.isDirectory() && !e2.name.startsWith(".")).length };
+    const entries2 = await readdir4(dir, { withFileTypes: true });
+    return { dir, repos: entries2.filter((e2) => e2.isDirectory() && !e2.name.startsWith(".")).length };
   } catch {
     return void 0;
   }
@@ -31571,6 +31838,10 @@ async function doctor() {
     out(`  ${found ? c.green("\u2714") : c.dim("\xB7")} ${bin}`);
   }
   out();
+  const hook = await hookStatus();
+  out("Cursor token usage");
+  out(`  ${hook.events.length ? c.green("\u2714") : c.dim("\xB7")} ${"Cursor hook".padEnd(12)} ${hook.events.length ? `recording (${hook.events.join(", ")})` : c.dim("off \xB7 reflex cursor-usage on")}`);
+  out();
 }
 async function sessions() {
   const store = new Store();
@@ -31662,12 +31933,18 @@ async function reset(opts) {
     out("Nothing to reset.");
     return;
   }
-  out(`This deletes Reflex's own data in ${displayPath(home)}: the local database (including sessions kept from deleted transcripts), generated skills and validation sandboxes.`);
+  out(`This deletes Reflex's own data in ${displayPath(home)}: the local database (including sessions kept from deleted transcripts), generated skills, validation sandboxes and recorded Cursor token counts.`);
   out(c.dim("Skills you installed into Claude Code, Codex or Cursor are not touched; Reflex's agent-memory block is removed. The embedding model is kept (`reflex model remove`)."));
   if (!await confirm("Delete Reflex data?", opts)) return;
   for (const w2 of await removeMemory()) if (w2.changed) ok(`Removed Reflex's memory block from ${displayPath(w2.path)}`);
-  for (const child of ["reflex.db", "reflex.db-journal", "reflex.db-wal", "reflex.db-shm", "skills", "validation"]) {
-    await rm3(join19(home, child), { recursive: true, force: true });
+  try {
+    const { removed } = await removeHook();
+    if (removed.length) ok(`Removed Reflex's hook from ${displayPath(cursorHooksFile())}`);
+  } catch (e2) {
+    warn(`Could not remove Reflex's Cursor hook: ${e2 instanceof Error ? e2.message : String(e2)}`);
+  }
+  for (const child of ["reflex.db", "reflex.db-journal", "reflex.db-wal", "reflex.db-shm", "skills", "validation", "cursor-usage.jsonl", "hooks"]) {
+    await rm3(join20(home, child), { recursive: true, force: true });
   }
   ok("Reset.");
 }
@@ -31680,9 +31957,9 @@ function reportWrites(writes) {
     else out(c.dim(`  ${w2.target.label}: ${displayPath(w2.path)} already up to date`));
   }
 }
-function find(entries, ref) {
+function find(entries2, ref) {
   const n = Number(ref.replace(/^#/, ""));
-  const e2 = Number.isInteger(n) && n > 0 ? entries[n - 1] : entries.find((x2) => x2.text === ref);
+  const e2 = Number.isInteger(n) && n > 0 ? entries2[n - 1] : entries2.find((x2) => x2.text === ref);
   if (!e2) throw new Error(`No memory entry "${ref.slice(0, 40)}". Run \`reflex memory\` to list them.`);
   return e2;
 }
@@ -31691,7 +31968,7 @@ async function memoryStatus() {
   try {
     await syncMemory(store, { mine: Boolean(store.latestScan()) });
     const { enabled } = store.memoryState();
-    const entries = store.memoryEntries();
+    const entries2 = store.memoryEntries();
     const targets = (await memoryTargets()).filter((t) => t.detected);
     title(`Agent memory \xB7 ${enabled ? c.green("on") : c.dim("off")}`);
     out(
@@ -31699,12 +31976,12 @@ async function memoryStatus() {
     );
     rows(targets.map((t) => [t.label, displayPath(t.file)]));
     out();
-    if (!entries.length) {
+    if (!entries2.length) {
       out(`Nothing to remember yet. Memory comes from corrections you gave in at least 2 independent sessions${store.latestScan() ? "" : "; run `reflex scan` first"}.`);
       out(c.dim('Add your own: reflex memory add "use pnpm, not npm"'));
       return;
     }
-    entries.forEach((e2, i) => {
+    entries2.forEach((e2, i) => {
       const meta4 = e2.origin === "added" ? "added by you" : plural(e2.sessions, "session");
       const line2 = `  ${String(i + 1).padStart(2)}. ${e2.text} ${c.dim(`(${meta4})`)}`;
       out(e2.status === "forgotten" ? c.dim(`${line2} forgotten`) : line2);
@@ -31917,11 +32194,87 @@ async function modelRemove(opts) {
   ok(next ? `Removed ${target.name}. Scans now use ${next.name}.` : `Removed ${target.name}. Scans will compare requests by words only.`);
 }
 
+// src/commands/cursor-usage.ts
+import { readFile as readFile8 } from "node:fs/promises";
+async function recorded() {
+  const conversations = /* @__PURE__ */ new Set();
+  let turns = 0;
+  let latest;
+  try {
+    for (const line2 of (await readFile8(paths.cursorUsage(), "utf8")).split("\n")) {
+      try {
+        const r2 = JSON.parse(line2);
+        if (r2.event !== "stop" || !r2.conversation_id) continue;
+        turns++;
+        conversations.add(r2.conversation_id);
+        if (r2.at && (!latest || r2.at > latest)) latest = r2.at;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return { turns, conversations, latest };
+}
+async function cursorUsageStatus() {
+  const file2 = cursorHooksFile();
+  const status = await hookStatus(file2);
+  const rec = await recorded();
+  title("Cursor token usage");
+  const on = status.events.length === HOOK_EVENTS.length;
+  rows([
+    ["Hook", on ? `${c.green("on")} ${c.dim(`\xB7 ${displayPath(file2)} (${status.events.join(", ")})`)}` : status.events.length ? c.yellow(`partly on (${status.events.join(", ")})`) : `off ${c.dim("\xB7 reflex cursor-usage on")}`],
+    ["Recorded", rec.turns ? `${plural(rec.turns, "turn")} in ${plural(rec.conversations.size, "chat")}${rec.latest ? c.dim(` \xB7 latest ${rec.latest.slice(0, 16).replace("T", " ")} UTC`) : ""}` : c.dim("nothing yet")],
+    ["Log", displayPath(paths.cursorUsage())]
+  ]);
+  if (status.error) warn(status.error);
+  if (on && !await pathExists(hookScript())) warn("The hook script is missing; run reflex cursor-usage on again.");
+  const store = new Store();
+  try {
+    if (store.latestScan() && rec.conversations.size) {
+      const priced = store.traces().filter((t) => t.source === "cursor" && t.usage).length;
+      out();
+      out(`  ${plural(priced, "Cursor chat")} in the last scan ${priced === 1 ? "has" : "have"} token counts. ${c.dim("reflex scan picks up new turns.")}`);
+    }
+  } finally {
+    store.close();
+  }
+  out();
+  out(c.dim("Cursor saves no token usage in its transcripts; its hooks receive it at the end of each agent turn. Only chats from when"));
+  out(c.dim("the hook is on get counts. Cursor's command-line agent in -p mode sends no end-of-turn hook, so those runs have none."));
+}
+async function cursorUsageOn(opts) {
+  assertHookSupported();
+  const file2 = cursorHooksFile();
+  title("Record Cursor token usage");
+  out("  Cursor sends each agent turn's token counts to its hooks. Reflex adds one hook that writes only the chat and turn");
+  out("  ids, the model and the four token counts to a local file. Never your prompt or the answer; no network.");
+  out();
+  rows([
+    ["Hooks file", `${displayPath(file2)} ${c.dim(`(adds ${HOOK_EVENTS.join(" and ")}; your other hooks stay as they are; a backup goes to ~/.reflex/backups)`)}`],
+    ["Runs", c.dim(hookCommand().replace(/'/g, ""))],
+    ["Writes to", displayPath(paths.cursorUsage())]
+  ]);
+  out();
+  if (!await confirm(`Add the hook to ${displayPath(file2)}?`, opts)) return;
+  const { added, backup } = await installHook(file2);
+  ok(added.length ? `Hook on (${added.join(", ")}). Cursor reloads hooks.json by itself; new turns are recorded from now on.` : "Hook was already on; its command is refreshed.");
+  if (backup) out(c.dim(`  Previous hooks file: ${displayPath(backup)}`));
+  out(c.dim("  reflex scan attaches the counts to your Cursor chats. reflex cursor-usage off removes the hook."));
+}
+async function cursorUsageOff() {
+  const { removed, backup } = await removeHook();
+  if (!removed.length) ok("The hook was not on.");
+  else ok(`Hook off (removed ${removed.join(", ")} from ${displayPath(cursorHooksFile())}).`);
+  if (backup) out(c.dim(`  Previous hooks file: ${displayPath(backup)}`));
+  out(c.dim(`  Recorded counts stay in ${displayPath(paths.cursorUsage())}; reflex reset deletes them.`));
+}
+
 // src/commands/improve.ts
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { delimiter, join as join20, resolve as resolve4 } from "node:path";
-var onPath = (cmd) => (process.env.PATH ?? "").split(delimiter).some((d3) => d3 && existsSync5(join20(d3, cmd)));
+import { delimiter as delimiter2, join as join21, resolve as resolve4 } from "node:path";
+var onPath = (cmd) => (process.env.PATH ?? "").split(delimiter2).some((d3) => d3 && existsSync5(join21(d3, cmd)));
 var unique = (xs) => [...new Map(xs.map((x2) => [x2.sessionId, x2])).values()];
 async function listSkills2(store) {
   const traces = unique(store.traces());
@@ -31937,8 +32290,8 @@ async function listSkills2(store) {
   for (const n of names.sort((a, b3) => loaded(b3) - loaded(a) || a.localeCompare(b3))) {
     const mine = found.filter((f) => f.name === n);
     const where = [...mine.map((f) => f.target), ...mine.some((f) => f.link) ? ["linked"] : []];
-    const count2 = loaded(n);
-    out(`  ${n.padEnd(28)} ${c.dim(where.join(", ").padEnd(28))} ${count2 ? `loaded in ${plural(count2, "session")}` : c.dim("not loaded in the last scan")}${own2.has(n) ? c.dim(" \xB7 generated by Reflex") : ""}`);
+    const count3 = loaded(n);
+    out(`  ${n.padEnd(28)} ${c.dim(where.join(", ").padEnd(28))} ${count3 ? `loaded in ${plural(count3, "session")}` : c.dim("not loaded in the last scan")}${own2.has(n) ? c.dim(" \xB7 generated by Reflex") : ""}`);
   }
   out();
   out(c.dim(`  reflex improve <name> compares a skill with the sessions that loaded it (needs ${MIN_REVIEW_SESSIONS}+).`));
@@ -31988,7 +32341,7 @@ async function verifyOutput(name, current, next, opts) {
   if (!Number.isInteger(runs) || runs < 1 || runs > 5) throw new Error("--runs must be 1 to 5.");
   if (!Number.isFinite(minutes) || minutes < 1 || minutes > 120) throw new Error("--timeout is minutes per run, 1 to 120.");
   out(c.dim(`  The check runs "${task}" ${plural(runs, "time")} with each version: ${plural(runs * 2, "non-persistent Claude Code session")} on your account, project settings only,`));
-  const benchRoot = join20(paths.home(), "bench");
+  const benchRoot = join21(paths.home(), "bench");
   out(c.dim(`  in fresh copies of ${displayPath(root)} at ${headCommit(root) ?? "HEAD"} under ${displayPath(benchRoot)} (deleted afterwards). Answers are compared in memory, never saved.`));
   if (!await confirm(`Run the before/after check?`, opts)) return void 0;
   await ensureDir(paths.home(), 448);
@@ -32000,7 +32353,7 @@ async function verifyOutput(name, current, next, opts) {
   for (let i = 0; i < runs; i++) {
     const shapes = { before: [], after: [] };
     for (const side of ["before", "after"]) {
-      const dir = join20(benchRoot, `improve-${name}-${side}-${randomUUID().slice(0, 8)}`);
+      const dir = join21(benchRoot, `improve-${name}-${side}-${randomUUID().slice(0, 8)}`);
       cloneRepo(root, dir);
       const spin = spinner();
       try {
@@ -32074,11 +32427,11 @@ async function improve(name, opts) {
       return;
     }
     const next = applyLearned(content, section2);
-    const proposalDir = assertInside(paths.home(), join20(paths.home(), "proposals", name));
+    const proposalDir = assertInside(paths.home(), join21(paths.home(), "proposals", name));
     await ensureDir(paths.home(), 448);
-    await ensureDir(join20(paths.home(), "proposals"), 448);
+    await ensureDir(join21(paths.home(), "proposals"), 448);
     await ensureDir(proposalDir, 448);
-    const proposal = join20(proposalDir, "SKILL.md");
+    const proposal = join21(proposalDir, "SKILL.md");
     await replaceOwnedFile(proposal, next, 384);
     out(c.bold("Proposed change"));
     fileBlock(displayPath(target.path), lineDiff(content, next));
@@ -32124,7 +32477,7 @@ async function improve(name, opts) {
     if (store.installations(name).some((i) => resolve4(i.path) === resolve4(target.path)))
       warn("Reflex installed this copy; after the change it counts as edited, so `reflex install`/remove will leave it alone.");
     if (!await confirm(`Apply it to ${displayPath(target.path)}? The current file is backed up first.`, opts)) return;
-    const backup = await applyToOwnSkill(target.path, sha256(content), next, join20(paths.home(), "backups"), name);
+    const backup = await applyToOwnSkill(target.path, sha256(content), next, join21(paths.home(), "backups"), name);
     store.updateSkillChange(changeId, { applied: true, backup: displayPath(backup) });
     ok(`Updated ${displayPath(target.path)}. Backup: ${displayPath(backup)}`);
   } finally {
@@ -32257,11 +32610,11 @@ async function handbookExport(opts) {
 import { spawnSync as spawnSync5 } from "node:child_process";
 import { randomInt, randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync6 } from "node:fs";
-import { basename as basename7, delimiter as delimiter2, join as join21 } from "node:path";
+import { basename as basename7, delimiter as delimiter3, join as join22 } from "node:path";
 var CLI = { "claude-code": "claude", codex: "codex" };
 var MODEL_NAME2 = /^[A-Za-z0-9][A-Za-z0-9._:[\]-]{0,63}$/;
 var CODEX_MODEL = /^(gpt|o\d|codex)/i;
-var onPath2 = (cmd) => (process.env.PATH ?? "").split(delimiter2).some((d3) => d3 && existsSync6(join21(d3, cmd)));
+var onPath2 = (cmd) => (process.env.PATH ?? "").split(delimiter3).some((d3) => d3 && existsSync6(join22(d3, cmd)));
 var unique2 = (traces) => [...new Map(traces.map((t) => [t.sessionId, t])).values()];
 var usd = (n) => n === void 0 ? "\u2014" : n < 0.01 ? "<$0.01" : `$${n.toFixed(2)}`;
 var fixes = (f) => `${f.toFixed(2)} fixes/request`;
@@ -32481,7 +32834,7 @@ async function bench(words2, opts) {
     const traces = unique2(store.traces());
     const kind = classifyRequest(task, traces).kind;
     const { tools, agentCanRunCheck } = benchTools(opts.check);
-    const benchRoot = join21(paths.home(), "bench");
+    const benchRoot = join22(paths.home(), "bench");
     const total = runs * models.length;
     const table2 = routingTable(traces);
     const typical = models.map((m2) => ({ m: m2, cost: typicalCost(table2, "claude-code", m2) }));
@@ -32515,7 +32868,7 @@ async function bench(words2, opts) {
     await ensureDir(benchRoot, 448);
     const batch = randomUUID2().slice(0, 8);
     const timeoutMs = minutes * 6e4;
-    const baseline = join21(benchRoot, `${batch}-before`);
+    const baseline = join22(benchRoot, `${batch}-before`);
     cloneRepo(root, baseline);
     try {
       if (opts.setup && !runUserCommand(baseline, opts.setup, timeoutMs)) throw new Error(`The setup command failed in a fresh copy: \`${opts.setup}\`. Fix it, then run bench again.`);
@@ -32528,7 +32881,7 @@ async function bench(words2, opts) {
     for (let i = 0; i < runs; i++) {
       const order = models.map((_3, j2) => models[(i + j2) % models.length]);
       for (const model2 of order) {
-        const dir = join21(benchRoot, `${batch}-${model2.replace(/[^A-Za-z0-9.-]/g, "_")}-${i + 1}`);
+        const dir = join22(benchRoot, `${batch}-${model2.replace(/[^A-Za-z0-9.-]/g, "_")}-${i + 1}`);
         cloneRepo(root, dir);
         const spin = spinner();
         try {
@@ -33166,8 +33519,8 @@ function renderMorning(w2, h2, data, _ui) {
     ...data.skills.items.map((x2) => ({ k: "skill", x: x2 })),
     ...(data.workflows?.items ?? []).map((x2) => ({ k: "wf", x: x2 }))
   ];
-  const tail = 4;
-  const cap = Math.max(2, Math.min(8, h2 - L3.length - tail - 3));
+  const tail2 = 4;
+  const cap = Math.max(2, Math.min(8, h2 - L3.length - tail2 - 3));
   const cw3 = Math.floor((w2 - 6) / 3);
   const col = (k3) => {
     const xs = all.filter((e2) => e2.x.state === k3);
@@ -34704,12 +35057,12 @@ var weekdayLabel = (d3) => `${WEEKDAYS[d3.getDay()]} ${dayLabel(d3).toLowerCase(
 var rangeLabel = (from, to) => `${dayLabel(from).toLowerCase()} \u2013 ${dayLabel(to).toLowerCase()}`;
 var clockLabel = (d3) => `${pad2(d3.getHours())}:${pad2(d3.getMinutes())}`;
 var dayStart = (d3, n = 0) => new Date(d3.getFullYear(), d3.getMonth(), d3.getDate() + n);
-var count = (n) => n.toLocaleString("en-US");
+var count2 = (n) => n.toLocaleString("en-US");
 
 // ../../packages/tui/src/live/skills.ts
 import { constants as constants4 } from "node:fs";
 import { lstat as lstat9, open as open6 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 var MAX_SKILL_BYTES = 64 * 1024;
 var TOOL_OF = { "claude-code": "claude", codex: "codex", cursor: "cursor" };
 var toolName = (target) => toCells(TOOL_OF[target] ?? target);
@@ -34733,9 +35086,9 @@ async function readCapped(file2) {
 }
 async function readReflexCopy(name) {
   if (!isValidSlug(name)) return void 0;
-  const dir = join22(paths.skills(), name);
+  const dir = join23(paths.skills(), name);
   if (await isSymlink(paths.skills()) || await isSymlink(dir)) return void 0;
-  return readCapped(join22(dir, "SKILL.md"));
+  return readCapped(join23(dir, "SKILL.md"));
 }
 async function isFile3(path) {
   try {
@@ -34784,7 +35137,7 @@ async function skillItems(store, scan2, targets, now) {
       state: found.has(k3.suggestionSlug) ? "" : "retired",
       steps: s?.steps.length ?? 0,
       path: path(name),
-      markdown: text === void 0 ? [toCells(`could not read ${displayPath(join22(paths.skills(), k3.name, "SKILL.md"))}`)] : toLines(text)
+      markdown: text === void 0 ? [toCells(`could not read ${displayPath(join23(paths.skills(), k3.name, "SKILL.md"))}`)] : toLines(text)
     });
   }
   return { items, targets: targets.filter((t) => t.detected).map((t) => toCells(`${displayPath(t.skillsDir)}/<name>/SKILL.md`)) };
@@ -34985,8 +35338,8 @@ function buildRouter(priced, rebuiltAt, windowDays2, autopilot = false) {
 }
 
 // ../../packages/tui/src/live/search.ts
-import { closeSync, constants as constants5, existsSync as existsSync7, lstatSync as lstatSync2, openSync, readSync, readdirSync, statSync as statSync3 } from "node:fs";
-import { basename as basename8, join as join23 } from "node:path";
+import { closeSync as closeSync2, constants as constants5, existsSync as existsSync7, lstatSync as lstatSync2, openSync as openSync2, readSync as readSync2, readdirSync, statSync as statSync3 } from "node:fs";
+import { basename as basename8, join as join24 } from "node:path";
 var SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
 var MAX_CWD_SCAN_BYTES = 256 * 1024;
 function buildSearch(priced) {
@@ -35001,13 +35354,13 @@ function buildSearch(priced) {
     meta4.set(key3, { usd: cost?.usd, turnCount: t.requests });
     const base = { date: at ? dayLabel(new Date(at)) : "\u2014", tool, project: toCells(t.projectName ?? "\u2014"), session: toCells(key3), at };
     const texts = [["you", t.excerpt], ...t.displaySteps.map((s) => ["ai", s])];
-    const entries = [];
+    const entries2 = [];
     texts.forEach(([role, raw], i) => {
       const text = toCells(raw).trim();
-      if (text) entries.push({ ...base, turn: i + 1, role, text, lower: text.toLowerCase() });
+      if (text) entries2.push({ ...base, turn: i + 1, role, text, lower: text.toLowerCase() });
     });
-    bySession.set(key3, entries);
-    all.push(...entries);
+    bySession.set(key3, entries2);
+    all.push(...entries2);
   }
   all.sort((a, b3) => b3.at - a.at || b3.turn - a.turn);
   const index = {
@@ -35031,19 +35384,19 @@ function claudeCwd(nativeId) {
     return void 0;
   }
   for (const dir of dirs) {
-    const file2 = join23(root, dir, `${nativeId}.jsonl`);
+    const file2 = join24(root, dir, `${nativeId}.jsonl`);
     try {
       if (!lstatSync2(file2).isFile()) continue;
     } catch {
       continue;
     }
-    const fd = openSync(file2, constants5.O_RDONLY | constants5.O_NOFOLLOW);
+    const fd = openSync2(file2, constants5.O_RDONLY | constants5.O_NOFOLLOW);
     const buf = Buffer.alloc(MAX_CWD_SCAN_BYTES);
     let n;
     try {
-      n = readSync(fd, buf, 0, buf.length, 0);
+      n = readSync2(fd, buf, 0, buf.length, 0);
     } finally {
-      closeSync(fd);
+      closeSync2(fd);
     }
     for (const line2 of buf.subarray(0, n).toString("utf8").split("\n")) {
       try {
@@ -35065,7 +35418,7 @@ function cursorWorkspace(nativeId) {
   } catch {
     return void 0;
   }
-  const dir = dirs.find((d3) => existsSync7(join23(root, d3, "agent-transcripts", nativeId)));
+  const dir = dirs.find((d3) => existsSync7(join24(root, d3, "agent-transcripts", nativeId)));
   return dir ? decodeWorkspace(dir) : void 0;
 }
 function resumeCommand(ref) {
@@ -35087,7 +35440,7 @@ function resumeCommand(ref) {
 
 // ../../packages/tui/src/live/workflows.ts
 var MAX_EVIDENCE = 12;
-var plural4 = (n, one, many = `${one}s`) => `${count(n)} ${n === 1 ? one : many}`;
+var plural4 = (n, one, many = `${one}s`) => `${count2(n)} ${n === 1 ? one : many}`;
 function workflowMarkdown(s) {
   const tools = SOURCE_IDS.filter((x2) => s.sources[x2]).map((x2) => `${TOOL_OF[x2]} ${s.sources[x2]}`);
   const L3 = [`# ${s.title}`, "", s.description, ""];
@@ -35095,7 +35448,7 @@ function workflowMarkdown(s) {
   L3.push(`confidence ${s.confidence.toFixed(2)} \xB7 verified in ${Math.round(s.verifiedRate * 100)}% of runs`);
   const cost = [];
   if (s.cost?.medianTokens !== void 0) cost.push(`median ${tok2(s.cost.medianTokens)} tokens`);
-  if (s.cost?.medianToolCalls !== void 0) cost.push(`median ${count(s.cost.medianToolCalls)} tool calls`);
+  if (s.cost?.medianToolCalls !== void 0) cost.push(`median ${count2(s.cost.medianToolCalls)} tool calls`);
   if (s.medianMinutes !== void 0) cost.push(`median ${s.medianMinutes < 120 ? `${Math.round(s.medianMinutes)} min` : `${(s.medianMinutes / 60).toFixed(1)} h`}`);
   if (cost.length) L3.push(`${cost.join(" \xB7 ")} per run`);
   L3.push("", "## Steps", "");
@@ -35117,7 +35470,7 @@ function workflowMarkdown(s) {
     const date5 = e2.date ? dayLabel(new Date(e2.date)) : "\u2014";
     L3.push(`- ${date5}  ${TOOL_OF[e2.source]}  ${e2.project ?? "\u2014"}  ${e2.excerpt}`);
   }
-  if (s.evidence.length > MAX_EVIDENCE) L3.push(`- +${count(s.evidence.length - MAX_EVIDENCE)} more (reflex evidence ${s.slug})`);
+  if (s.evidence.length > MAX_EVIDENCE) L3.push(`- +${count2(s.evidence.length - MAX_EVIDENCE)} more (reflex evidence ${s.slug})`);
   return L3.map(toCells);
 }
 function workflowItems(suggestions, skillOf, skills, foundOn) {
@@ -35269,21 +35622,21 @@ function addCosts(data, c2) {
 var uniqueSessions = (traces) => [...new Map(traces.map((t) => [t.sessionId, t])).values()];
 function totals(traces) {
   const usage2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-  let recorded = 0;
+  let recorded2 = 0;
   for (const t of traces) {
     if (!t.usage) continue;
-    recorded++;
+    recorded2++;
     usage2.input += t.usage.input;
     usage2.output += t.usage.output;
     usage2.cacheRead += t.usage.cacheRead;
     usage2.cacheWrite += t.usage.cacheWrite;
   }
-  return { sessions: traces.length, usage: usage2, measured: traces.length === 0 || recorded > 0 };
+  return { sessions: traces.length, usage: usage2, measured: traces.length === 0 || recorded2 > 0 };
 }
 function cursorModels(traces) {
   const counts = /* @__PURE__ */ new Map();
   for (const t of traces) {
-    const m2 = t.source === "cursor" ? t.models?.[0] : void 0;
+    const m2 = t.source === "cursor" && !t.usage ? t.models?.[0] : void 0;
     if (m2) counts.set(m2, (counts.get(m2) ?? 0) + 1);
   }
   if (!counts.size) return void 0;
@@ -35329,9 +35682,9 @@ function attention2(items) {
   return out2;
 }
 async function agentMemory(store) {
-  const entries = store.memoryEntries().filter((e2) => e2.status === "active").map((e2) => ({ text: toCells(e2.text), sessions: e2.sessions, origin: e2.origin }));
+  const entries2 = store.memoryEntries().filter((e2) => e2.status === "active").map((e2) => ({ text: toCells(e2.text), sessions: e2.sessions, origin: e2.origin }));
   const files = (await memoryTargets()).filter((t) => t.detected).map((t) => toCells(displayPath(t.file)));
-  return { enabled: store.memoryState().enabled, entries, files };
+  return { enabled: store.memoryState().enabled, entries: entries2, files };
 }
 
 // src/commands/tui.ts
@@ -35392,7 +35745,7 @@ function run(fn) {
   };
 }
 var program2 = new Command();
-program2.name("reflex").description("Find workflows you keep re-teaching Claude Code, Codex and Cursor, and turn proven repeats into reusable skills. Everything runs locally.").version("0.5.1").allowExcessArguments().action(
+program2.name("reflex").description("Find workflows you keep re-teaching Claude Code, Codex and Cursor, and turn proven repeats into reusable skills. Everything runs locally.").version("0.5.2").allowExcessArguments().action(
   run(async () => {
     if (program2.args.length) program2.error(`error: unknown command '${program2.args[0]}'. See \`reflex --help\`.`);
     if (process.stdin.isTTY && process.stdout.isTTY) await tui();
@@ -35442,6 +35795,10 @@ route.command("status", { isDefault: true }).description("show picks, settings,
 route.command("autopilot <state>").description("on: reflex run starts on the pick without asking; off: it asks").action(run(routeAutopilot));
 route.command("explore <percent>").description("try another model you use on this share of reflex runs, chosen at random (off to stop)").option("--protect <kind...>", "kinds of task never explored: review, ci, debug, feature, edit, research, explore").action(run(async (value, o2) => routeExplore(value, o2)));
 program2.command("bench <task...>").description("run one task on several Claude Code models, each in a fresh copy of this repository, scored by your check command").requiredOption("--models <model...>", "models to compare, e.g. sonnet opus").requiredOption("--check <command>", 'command that passes (exit 0) when the task is done, e.g. "pnpm test"').option("--setup <command>", 'command to prepare each copy, e.g. "pnpm install --frozen-lockfile"').option("--runs <n>", "runs per model", "1").option("--timeout <minutes>", "time limit per run", "20").option("--keep", "keep the copies for inspection").option("-y, --yes", "start without asking").action(run(async (words2, o2) => bench(words2, o2)));
+var cursorUsage = program2.command("cursor-usage").description("record Cursor's token counts locally through a Cursor hook (Cursor saves none in its transcripts)");
+cursorUsage.command("status", { isDefault: true }).description("whether the hook is on and what it has recorded").action(run(cursorUsageStatus));
+cursorUsage.command("on").description("add Reflex's hook to ~/.cursor/hooks.json (asks first; keeps your other hooks)").option("-y, --yes", "add it without prompting").action(run(cursorUsageOn));
+cursorUsage.command("off").description("remove Reflex's hook; recorded counts stay").action(run(cursorUsageOff));
 program2.command("stats").description("defensible counts from local data").action(run(stats2));
 program2.command("reset").description("delete Reflex's own local data (not installed skills)").option("-y, --yes", "consent without prompting").action(run(reset));
 await program2.parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reflex-skills",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "type": "module",
   "description": "Turn repeated Claude Code and Codex workflows into reusable skills, locally.",
   "license": "MIT",