reflex-skills 0.5.0 → 0.5.2

package/dist/reflex.js

@@ -590,8 +590,8 @@ var require_help = __commonJS({
           helper.visibleCommands(cmd),
           (sub) => sub.helpGroup() || "Commands:"
         );
-        commandGroups.forEach((commands, group) => {
-          const commandList = commands.map((sub) => {
+        commandGroups.forEach((commands2, group) => {
+          const commandList = commands2.map((sub) => {
             return callFormatItem(
               helper.styleSubcommandTerm(helper.subcommandTerm(sub)),
               helper.styleSubcommandDescription(helper.subcommandDescription(sub))
@@ -742,8 +742,8 @@ ${itemIndentStr}`);
         const rawLines = str3.split(/\r\n|\n/);
         const chunkPattern = /[\s]*[^\s]+/g;
         const wrappedLines = [];
-        rawLines.forEach((line) => {
-          const chunks = line.match(chunkPattern);
+        rawLines.forEach((line2) => {
+          const chunks = line2.match(chunkPattern);
           if (chunks === null) {
             wrappedLines.push("");
             return;
@@ -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;
       }
@@ -3571,12 +3571,103 @@ var require_picocolors = __commonJS({
 });
 
 // src/guard.ts
+import dgram from "node:dgram";
+import dns from "node:dns";
+import { syncBuiltinESMExports } from "node:module";
 import net from "node:net";
+import threads from "node:worker_threads";
+var MESSAGE = "Reflex does not make network connections";
+var MODEL_HOSTS = ["huggingface.co", "hf.co"];
+var DNS_QUERIES = /^(lookup|lookupService|resolve\w*|reverse)$/;
+var WORKER_GUARD = `{
+  const blocked = () => { throw new Error(${JSON.stringify(`${MESSAGE}.`)}); };
+  const get = process.getBuiltinModule;
+  get("node:net").Socket.prototype.connect = blocked;
+  const udp = get("node:dgram").Socket.prototype;
+  udp.send = udp.connect = blocked;
+  const dns = get("node:dns");
+  for (const target of [dns, dns.promises, dns.Resolver.prototype, dns.promises.Resolver.prototype])
+    for (const key of Object.getOwnPropertyNames(target))
+      if (${DNS_QUERIES}.test(key) && typeof target[key] === "function") target[key] = blocked;
+}`;
+var allowed = [];
+function hostAllowed(host) {
+  if (typeof host !== "string") return false;
+  const h2 = host.toLowerCase().replace(/\.$/, "");
+  return allowed.some((a) => h2 === a || h2.endsWith(`.${a}`));
+}
+function connectHost(args) {
+  const first = Array.isArray(args[0]) ? args[0][0] : args[0];
+  if (typeof first === "object" && first !== null) {
+    const o2 = first;
+    return o2.path === void 0 ? o2.host ?? "localhost" : void 0;
+  }
+  if (typeof first === "number" || /^\d+$/.test(String(first))) return typeof args[1] === "string" ? args[1] : "localhost";
+  return void 0;
+}
+var refuse = (host) => {
+  throw new Error(typeof host === "string" ? `${MESSAGE} (blocked ${host}).` : `${MESSAGE}.`);
+};
 function installNetworkGuard() {
-  const blocked = function connect() {
-    throw new Error("Reflex does not make network connections.");
+  const undo = [];
+  const patch = (target, key3, make) => {
+    const t = target;
+    const original = t[key3];
+    t[key3] = make(original);
+    undo.push(() => t[key3] = original);
+  };
+  patch(
+    net.Socket.prototype,
+    "connect",
+    (original) => function connect(...args) {
+      const host = connectHost(args);
+      return hostAllowed(host) ? original.apply(this, args) : refuse(host);
+    }
+  );
+  for (const key3 of ["send", "connect"]) patch(dgram.Socket.prototype, key3, () => () => refuse(void 0));
+  for (const target of [dns, dns.promises, dns.Resolver.prototype, dns.promises.Resolver.prototype]) {
+    for (const key3 of Object.getOwnPropertyNames(target)) {
+      if (!DNS_QUERIES.test(key3) || typeof target[key3] !== "function") continue;
+      patch(
+        target,
+        key3,
+        (original) => key3 === "lookup" ? function lookup(...args) {
+          return hostAllowed(args[0]) ? original.apply(this, args) : refuse(args[0]);
+        } : () => refuse(void 0)
+      );
+    }
+  }
+  const Base = threads.Worker;
+  class GuardedWorker extends Base {
+    constructor(filename, options = {}) {
+      const inline = options.eval === true && typeof filename === "string";
+      const guard = ["--import", `data:text/javascript,${encodeURIComponent(WORKER_GUARD)}`];
+      super(inline ? `${WORKER_GUARD}
+${filename}` : filename, inline ? options : { ...options, execArgv: [...options.execArgv ?? process.execArgv, ...guard] });
+    }
+  }
+  patch(threads, "Worker", () => GuardedWorker);
+  syncBuiltinESMExports();
+  return () => {
+    for (const fn of undo.reverse()) fn();
+    syncBuiltinESMExports();
   };
-  net.Socket.prototype.connect = blocked;
+}
+function allowHosts(hosts) {
+  const before = allowed;
+  allowed = [...before, ...hosts, ...proxyHosts()];
+  return () => {
+    allowed = before;
+  };
+}
+function proxyHosts() {
+  if (!process.env.NODE_USE_ENV_PROXY) return [];
+  const url2 = process.env.HTTPS_PROXY ?? process.env.https_proxy;
+  try {
+    return url2 ? [new URL(url2).hostname.toLowerCase()] : [];
+  } catch {
+    return [];
+  }
 }
 function quietSqliteWarning() {
   const listeners = process.listeners("warning");
@@ -4286,8 +4377,8 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 var import_picocolors3 = __toESM(require_picocolors(), 1);
 var c = import_picocolors3.default;
 var interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
-function out(line = "") {
-  process.stdout.write(line + "\n");
+function out(line2 = "") {
+  process.stdout.write(line2 + "\n");
 }
 function title(text) {
   out();
@@ -4359,7 +4450,7 @@ async function ask(message, initial, validate3) {
 }
 function fileBlock(path, content) {
   out(c.dim(`\u250C\u2500 ${path}`));
-  for (const line of content.trimEnd().split("\n")) out(`${c.dim("\u2502")} ${line}`);
+  for (const line2 of content.trimEnd().split("\n")) out(`${c.dim("\u2502")} ${line2}`);
   out(c.dim("\u2514\u2500"));
 }
 function spinner() {
@@ -5151,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 = "|") {
@@ -5690,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))
@@ -6976,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 = []);
@@ -7048,8 +7139,8 @@ var Doc = class {
     const lines = content.split("\n").filter((x2) => x2);
     const minIndent = Math.min(...lines.map((x2) => x2.length - x2.trimStart().length));
     const dedented = lines.map((x2) => x2.slice(minIndent)).map((x2) => " ".repeat(this.indent * 2) + x2);
-    for (const line of dedented) {
-      this.content.push(line);
+    for (const line2 of dedented) {
+      this.content.push(line2);
     }
   }
   compile() {
@@ -10052,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) {
@@ -12700,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)
@@ -15439,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) {
@@ -17337,10 +17428,10 @@ var $ZodRegistry = class {
     this._idmap = /* @__PURE__ */ new Map();
   }
   add(schema, ..._meta) {
-    const meta3 = _meta[0];
-    this._map.set(schema, meta3);
-    if (meta3 && typeof meta3 === "object" && "id" in meta3) {
-      this._idmap.set(meta3.id, schema);
+    const meta4 = _meta[0];
+    this._map.set(schema, meta4);
+    if (meta4 && typeof meta4 === "object" && "id" in meta4) {
+      this._idmap.set(meta4.id, schema);
     }
     return this;
   }
@@ -17350,9 +17441,9 @@ var $ZodRegistry = class {
     return this;
   }
   remove(schema) {
-    const meta3 = this._map.get(schema);
-    if (meta3 && typeof meta3 === "object" && "id" in meta3) {
-      this._idmap.delete(meta3.id);
+    const meta4 = this._map.get(schema);
+    if (meta4 && typeof meta4 === "object" && "id" in meta4) {
+      this._idmap.delete(meta4.id);
     }
     this._map.delete(schema);
     return this;
@@ -19767,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)
   });
 }
@@ -20074,13 +20165,13 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function handleUnrepresentable(schema, ctx, json2, params, message) {
+function handleUnrepresentable(schema, ctx, json3, params, message) {
   const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({ zodSchema: schema, path: params.path, message }) : ctx.unrepresentable;
   if (result === "any")
     return false;
   if (result === void 0 || result === "throw")
     throw new Error(message);
-  Object.assign(json2, result);
+  Object.assign(json3, result);
   return true;
 }
 function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
@@ -20126,9 +20217,9 @@ function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta3 = ctx.metadataRegistry.get(schema);
-  if (meta3)
-    assignProps(result.schema, meta3);
+  const meta4 = ctx.metadataRegistry.get(schema);
+  if (meta4)
+    assignProps(result.schema, meta4);
   if (ctx.io === "input" && isTransforming(schema)) {
     delete result.schema.examples;
     delete result.schema.default;
@@ -20316,12 +20407,12 @@ function foldObjects(members2) {
   }
   return folded;
 }
-function foldIntersection(json2) {
-  const allOf = json2.allOf;
+function foldIntersection(json3) {
+  const allOf = json3.allOf;
   if (!Array.isArray(allOf) || allOf.length < 2)
     return;
   for (const key3 of FOLDABLE_KEYS)
-    if (key3 in json2)
+    if (key3 in json3)
       return;
   const unions = allOf.filter((m2) => UNION_KEYS.some((k3) => Array.isArray(m2[k3])));
   let folded = null;
@@ -20340,8 +20431,8 @@ function foldIntersection(json2) {
   }
   if (!folded)
     return;
-  delete json2.allOf;
-  assignProps(json2, folded);
+  delete json3.allOf;
+  assignProps(json3, folded);
 }
 function finalize(ctx, schema) {
   const root = ctx.seen.get(schema);
@@ -20423,20 +20514,20 @@ function finalize(ctx, schema) {
     if (ctx.intersections.length) {
       const carriers = /* @__PURE__ */ new Map();
       for (const seen of ctx.seen.values()) {
-        for (const json2 of [seen.schema, seen.def]) {
-          const allOf = json2?.allOf;
+        for (const json3 of [seen.schema, seen.def]) {
+          const allOf = json3?.allOf;
           if (!Array.isArray(allOf))
             continue;
           const existing = carriers.get(allOf);
           if (existing)
-            existing.push(json2);
+            existing.push(json3);
           else
-            carriers.set(allOf, [json2]);
+            carriers.set(allOf, [json3]);
         }
       }
       for (const allOf of ctx.intersections) {
-        for (const json2 of carriers.get(allOf) ?? [])
-          foldIntersection(json2);
+        for (const json3 of carriers.get(allOf) ?? [])
+          foldIntersection(json3);
       }
     }
   }
@@ -20671,29 +20762,29 @@ var exactPatterns = /* @__PURE__ */ new Map([
 ]);
 var exactPattern = (p3) => exactPatterns.get(p3) ?? p3;
 var stringProcessor = (schema, ctx, _json, _params) => {
-  const json2 = _json;
-  json2.type = "string";
+  const json3 = _json;
+  json3.type = "string";
   const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minLength = minimum;
+    json3.minLength = minimum;
   if (typeof maximum === "number")
-    json2.maxLength = maximum;
+    json3.maxLength = maximum;
   if (format) {
-    json2.format = formatMap[format] ?? format;
-    if (json2.format === "")
-      delete json2.format;
+    json3.format = formatMap[format] ?? format;
+    if (json3.format === "")
+      delete json3.format;
     if (format === "time" || laxFormat) {
-      delete json2.format;
+      delete json3.format;
     }
   }
   if (contentEncoding)
-    json2.contentEncoding = contentEncoding;
+    json3.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const patternList = [...patterns].map(exactPattern);
     if (patternList.length === 1)
-      json2.pattern = patternList[0].source;
+      json3.pattern = patternList[0].source;
     else if (patternList.length > 1) {
-      json2.allOf = [
+      json3.allOf = [
         ...patternList.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -20703,31 +20794,31 @@ var stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 var numberProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt: isInt2 } = aggregateChecks(schema);
-  json2.type = isInt2 ? "integer" : "number";
+  json3.type = isInt2 ? "integer" : "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
   const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
   if (exMin) {
     if (legacy) {
-      json2.minimum = exclusiveMinimum;
-      json2.exclusiveMinimum = true;
+      json3.minimum = exclusiveMinimum;
+      json3.exclusiveMinimum = true;
     } else {
-      json2.exclusiveMinimum = exclusiveMinimum;
+      json3.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json2.minimum = minimum;
+    json3.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json2.maximum = exclusiveMaximum;
-      json2.exclusiveMaximum = true;
+      json3.maximum = exclusiveMaximum;
+      json3.exclusiveMaximum = true;
     } else {
-      json2.exclusiveMaximum = exclusiveMaximum;
+      json3.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json2.maximum = maximum;
+    json3.maximum = maximum;
   }
   if (multipleOf) {
     const divisors = /* @__PURE__ */ new Set();
@@ -20735,75 +20826,75 @@ var numberProcessor = (schema, ctx, _json, params) => {
       if (Number.isFinite(divisor) && divisor !== 0)
         divisors.add(Math.abs(divisor));
       else
-        handleUnrepresentable(schema, ctx, json2, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
+        handleUnrepresentable(schema, ctx, json3, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
     const [first, ...rest] = divisors;
     if (first !== void 0)
-      json2.multipleOf = first;
+      json3.multipleOf = first;
     if (rest.length)
-      json2.allOf = [...json2.allOf ?? [], ...rest.map((m2) => ({ multipleOf: m2 }))];
+      json3.allOf = [...json3.allOf ?? [], ...rest.map((m2) => ({ multipleOf: m2 }))];
   }
 };
-var booleanProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var booleanProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
-var bigintProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt cannot be represented in JSON Schema");
+var bigintProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt cannot be represented in JSON Schema");
 };
-var symbolProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Symbols cannot be represented in JSON Schema");
+var symbolProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Symbols cannot be represented in JSON Schema");
 };
-var nullProcessor = (_schema, ctx, json2, _params) => {
+var nullProcessor = (_schema, ctx, json3, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json2.type = "string";
-    json2.nullable = true;
-    json2.enum = [null];
+    json3.type = "string";
+    json3.nullable = true;
+    json3.enum = [null];
   } else {
-    json2.type = "null";
+    json3.type = "null";
   }
 };
-var undefinedProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Undefined cannot be represented in JSON Schema");
+var undefinedProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Undefined cannot be represented in JSON Schema");
 };
-var voidProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Void cannot be represented in JSON Schema");
+var voidProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Void cannot be represented in JSON Schema");
 };
-var neverProcessor = (_schema, _ctx, json2, _params) => {
-  json2.not = {};
+var neverProcessor = (_schema, _ctx, json3, _params) => {
+  json3.not = {};
 };
 var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
 var unknownProcessor = (_schema, _ctx, _json, _params) => {
 };
-var dateProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Date cannot be represented in JSON Schema");
+var dateProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Date cannot be represented in JSON Schema");
 };
-var enumProcessor = (schema, _ctx, json2, _params) => {
+var enumProcessor = (schema, _ctx, json3, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   if (values.every((v2) => typeof v2 === "number"))
-    json2.type = "number";
+    json3.type = "number";
   if (values.every((v2) => typeof v2 === "string"))
-    json2.type = "string";
-  json2.enum = values;
+    json3.type = "string";
+  json3.enum = values;
 };
-var literalProcessor = (schema, ctx, json2, params) => {
+var literalProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   if (def.values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
-      if (handleUnrepresentable(schema, ctx, json2, params, "Literal `undefined` cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "Literal `undefined` cannot be represented in JSON Schema"))
         return;
     } else if (typeof val === "bigint") {
-      if (handleUnrepresentable(schema, ctx, json2, params, "BigInt literals cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "BigInt literals cannot be represented in JSON Schema"))
         return;
       vals.push(Number(val));
     } else {
@@ -20813,37 +20904,37 @@ var literalProcessor = (schema, ctx, json2, params) => {
   if (vals.length === 0) {
   } else if (vals.length === 1) {
     const val = vals[0];
-    json2.type = val === null ? "null" : typeof val;
+    json3.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json2.enum = [val];
+      json3.enum = [val];
     } else {
-      json2.const = val;
+      json3.const = val;
     }
   } else {
     if (vals.every((v2) => typeof v2 === "number"))
-      json2.type = "number";
+      json3.type = "number";
     if (vals.every((v2) => typeof v2 === "string"))
-      json2.type = "string";
+      json3.type = "string";
     if (vals.every((v2) => typeof v2 === "boolean"))
-      json2.type = "boolean";
+      json3.type = "boolean";
     if (vals.every((v2) => v2 === null))
-      json2.type = "null";
-    json2.enum = vals;
+      json3.type = "null";
+    json3.enum = vals;
   }
 };
-var nanProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "NaN cannot be represented in JSON Schema");
+var nanProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "NaN cannot be represented in JSON Schema");
 };
-var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var templateLiteralProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var fileProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   _json.type = "string";
   _json.format = "binary";
   _json.contentEncoding = "binary";
@@ -20861,34 +20952,34 @@ var fileProcessor = (schema, _ctx, json2, _params) => {
   else
     _json.anyOf = mime.map((m2) => ({ contentMediaType: m2 }));
 };
-var successProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var successProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
-var customProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Custom types cannot be represented in JSON Schema");
+var customProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Custom types cannot be represented in JSON Schema");
 };
-var functionProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Function types cannot be represented in JSON Schema");
+var functionProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Function types cannot be represented in JSON Schema");
 };
-var transformProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Transforms cannot be represented in JSON Schema");
+var transformProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Transforms cannot be represented in JSON Schema");
 };
-var mapProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Map cannot be represented in JSON Schema");
+var mapProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Map cannot be represented in JSON Schema");
 };
-var setProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Set cannot be represented in JSON Schema");
+var setProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Set cannot be represented in JSON Schema");
 };
 var arrayProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
-  json2.type = "array";
-  json2.items = processSchema(def.element, ctx, {
+    json3.maxItems = maximum;
+  json3.type = "array";
+  json3.items = processSchema(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -20904,17 +20995,17 @@ function inputOptin(schema) {
   return schema._zod.optin;
 }
 var objectProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const shape = def.shape;
   const symbolKeys = Object.getOwnPropertySymbols(shape);
-  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json2, params, "Symbol keys cannot be represented in JSON Schema")) {
+  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json3, params, "Symbol keys cannot be represented in JSON Schema")) {
     return;
   }
-  json2.type = "object";
-  json2.properties = {};
+  json3.type = "object";
+  json3.properties = {};
   for (const key3 in shape) {
-    assignProp(json2.properties, key3, processSchema(shape[key3], ctx, {
+    assignProp(json3.properties, key3, processSchema(shape[key3], ctx, {
       ...params,
       path: [...params.path, "properties", key3]
     }));
@@ -20927,21 +21018,21 @@ var objectProcessor = (schema, ctx, _json, params) => {
     }
   }
   if (requiredKeys.length > 0) {
-    json2.required = requiredKeys;
+    json3.required = requiredKeys;
   }
   if (def.catchall?._zod.def.type === "never") {
-    json2.additionalProperties = false;
+    json3.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json2.additionalProperties = false;
+      json3.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = processSchema(def.catchall, ctx, {
+    json3.additionalProperties = processSchema(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-var unionProcessor = (schema, ctx, json2, params) => {
+var unionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x2, i) => processSchema(x2, ctx, {
@@ -20949,12 +21040,12 @@ var unionProcessor = (schema, ctx, json2, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
   if (isExclusive) {
-    json2.oneOf = options;
+    json3.oneOf = options;
   } else {
-    json2.anyOf = options;
+    json3.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json2, params) => {
+var intersectionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const a = processSchema(def.left, ctx, {
     ...params,
@@ -20969,13 +21060,13 @@ var intersectionProcessor = (schema, ctx, json2, params) => {
     ...isSimpleIntersection(a) ? a.allOf : [a],
     ...isSimpleIntersection(b3) ? b3.allOf : [b3]
   ];
-  json2.allOf = allOf;
+  json3.allOf = allOf;
   ctx.intersections.push(allOf);
 };
 var tupleProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "array";
+  json3.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
   const prefixItems = def.items.map((x2, i) => processSchema(x2, ctx, {
@@ -20997,70 +21088,70 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   const maxItems = def.items.length;
   const isClosed = !def.rest;
   if (ctx.target === "draft-2020-12") {
-    json2.prefixItems = prefixItems;
+    json3.prefixItems = prefixItems;
     if (isClosed) {
-      json2.items = false;
+      json3.items = false;
     } else if (rest) {
-      json2.items = rest;
+      json3.items = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else if (ctx.target === "openapi-3.0") {
-    json2.items = {
+    json3.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json2.items.anyOf.push(rest);
+      json3.items.anyOf.push(rest);
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else {
-    json2.items = prefixItems;
+    json3.items = prefixItems;
     if (isClosed) {
-      json2.additionalItems = false;
+      json3.additionalItems = false;
     } else if (rest) {
-      json2.additionalItems = rest;
+      json3.additionalItems = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   }
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
+    json3.maxItems = maximum;
 };
-function stringifyKeyNames(bySchema, json2, visited) {
-  if (json2.$ref) {
-    if (visited.has(json2))
-      return json2;
-    visited.add(json2);
-    const def = bySchema.get(json2)?.def;
+function stringifyKeyNames(bySchema, json3, visited) {
+  if (json3.$ref) {
+    if (visited.has(json3))
+      return json3;
+    visited.add(json3);
+    const def = bySchema.get(json3)?.def;
     if (!def)
-      return json2;
+      return json3;
     const inlined = stringifyKeyNames(bySchema, def, visited);
-    return inlined === def ? json2 : inlined;
+    return inlined === def ? json3 : inlined;
   }
   for (const keyword of ["anyOf", "oneOf"]) {
-    const branches = json2[keyword];
+    const branches = json3[keyword];
     if (!Array.isArray(branches))
       continue;
     const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
     if (mapped.some((branch, i) => branch !== branches[i]))
-      json2 = { ...json2, [keyword]: mapped };
+      json3 = { ...json3, [keyword]: mapped };
   }
-  const types = Array.isArray(json2.type) ? json2.type : [json2.type];
+  const types = Array.isArray(json3.type) ? json3.type : [json3.type];
   const numericType = !types.includes("string") && types.some((t) => t === "number" || t === "integer");
-  const values = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
+  const values = json3.enum ?? (json3.const !== void 0 ? [json3.const] : void 0);
   if (!numericType && !values?.some((v2) => typeof v2 === "number"))
-    return json2;
-  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json2;
+    return json3;
+  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json3;
   if (rest.enum)
     rest.enum = rest.enum.map((v2) => typeof v2 === "number" ? String(v2) : v2);
   else if (typeof rest.const === "number")
@@ -21100,9 +21191,9 @@ function rewriteKeyNames(ctx) {
   }
 }
 var recordProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
+  json3.type = "object";
   const keyType = def.keyType;
   const patterns = aggregateChecks(keyType).patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
@@ -21110,13 +21201,13 @@ var recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json2.patternProperties = {};
+    json3.patternProperties = {};
     for (const pattern of patterns) {
-      assignProp(json2.patternProperties, exactPattern(pattern).source, valueSchema);
+      assignProp(json3.patternProperties, exactPattern(pattern).source, valueSchema);
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = processSchema(def.keyType, ctx, {
+      json3.propertyNames = processSchema(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
@@ -21128,7 +21219,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
       }
       pending.push(schema);
     }
-    json2.additionalProperties = processSchema(def.valueType, ctx, {
+    json3.additionalProperties = processSchema(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -21138,19 +21229,19 @@ var recordProcessor = (schema, ctx, _json, params) => {
   if (keyValues && !def.partial && !omittableOnInput) {
     const validKeyValues = [...keyValues].filter((v2) => typeof v2 === "string" || typeof v2 === "number");
     if (validKeyValues.length > 0) {
-      json2.required = validKeyValues.map(String);
+      json3.required = validKeyValues.map(String);
     }
   }
 };
-var nullableProcessor = (schema, ctx, json2, params) => {
+var nullableProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const inner = processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json2.nullable = true;
+    json3.nullable = true;
   } else {
-    json2.anyOf = [inner, { type: "null" }];
+    json3.anyOf = [inner, { type: "null" }];
   }
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -21160,7 +21251,7 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   seen.ref = def.innerType;
 };
 var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
-function serializeDefaultValue(value, schema, ctx, json2, params) {
+function serializeDefaultValue(value, schema, ctx, json3, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_3, val) => {
     if (typeof val !== "bigint")
@@ -21170,30 +21261,30 @@ function serializeDefaultValue(value, schema, ctx, json2, params) {
   });
   if (!unrepresentable)
     return JSON.parse(serialized);
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt defaults cannot be represented in JSON Schema");
   return UNREPRESENTABLE_DEFAULT;
 }
-var defaultProcessor = (schema, ctx, json2, params) => {
+var defaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2.default = value;
+    json3.default = value;
 };
-var prefaultProcessor = (schema, ctx, json2, params) => {
+var prefaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io !== "input")
     return;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2._prefault = value;
+    json3._prefault = value;
 };
-var catchProcessor = (schema, ctx, json2, params) => {
+var catchProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -21202,10 +21293,10 @@ var catchProcessor = (schema, ctx, json2, params) => {
   try {
     catchValue = def.catchValue(void 0);
   } catch {
-    handleUnrepresentable(schema, ctx, json2, params, "Dynamic catch values are not supported in JSON Schema");
+    handleUnrepresentable(schema, ctx, json3, params, "Dynamic catch values are not supported in JSON Schema");
     return;
   }
-  json2.default = catchValue;
+  json3.default = catchValue;
 };
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -21215,12 +21306,12 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json2, params) => {
+var readonlyProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.readOnly = true;
+  json3.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -21707,8 +21798,8 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   brand() {
     return this;
   },
-  register(reg, meta3) {
-    reg.add(this, meta3);
+  register(reg, meta4) {
+    reg.add(this, meta4);
     return this;
   },
   refine(check2, params) {
@@ -21862,7 +21953,7 @@ var _ZodString = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodString.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     format: (inst) => aggregateChecks(inst).format ?? null,
@@ -22221,7 +22312,7 @@ var ZodNumber = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
     inst.isFinite = true;
   },
   /* @__PURE__ */ util_exports.derived({
@@ -22311,7 +22402,7 @@ function uint32(params) {
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
 });
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
@@ -22321,7 +22412,7 @@ var ZodBigInt = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     minValue: (inst) => aggregateChecks(inst).minimum ?? null,
@@ -22379,7 +22470,7 @@ function uint64(params) {
 var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
   $ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
 });
 function symbol(params) {
   return _symbol(ZodSymbol, params);
@@ -22387,7 +22478,7 @@ function symbol(params) {
 var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
   $ZodUndefined.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
 });
 function _undefined3(params) {
   return _undefined2(ZodUndefined, params);
@@ -22395,7 +22486,7 @@ function _undefined3(params) {
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
 });
 function _null3(params) {
   return _null2(ZodNull, params);
@@ -22403,7 +22494,7 @@ function _null3(params) {
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
   $ZodAny.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
 });
 function any() {
   return _any(ZodAny);
@@ -22411,7 +22502,7 @@ function any() {
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
 });
 function unknown() {
   return _unknown(ZodUnknown);
@@ -22419,7 +22510,7 @@ function unknown() {
 var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
 });
 function never(params) {
   return _never(ZodNever, params);
@@ -22427,7 +22518,7 @@ function never(params) {
 var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
   $ZodVoid.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
 });
 function _void2(params) {
   return _void(ZodVoid, params);
@@ -22437,7 +22528,7 @@ var ZodDate = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodDate.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
     inst.min = (value, params) => inst.check(_gte(value, params));
     inst.max = (value, params) => inst.check(_lte(value, params));
   },
@@ -22459,7 +22550,7 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
   inst.element = def.element;
 }, {
   min(n, params) {
@@ -22489,7 +22580,7 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
   util_exports.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 }, {
   keyof() {
@@ -22562,7 +22653,7 @@ function looseObject(shape, params) {
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -22575,7 +22666,7 @@ function union(options, params) {
 var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
   ZodUnion.init(inst, def);
   $ZodXor.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function xor(options, params) {
@@ -22601,7 +22692,7 @@ function discriminatedUnion(discriminator, options, params) {
 var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -22614,7 +22705,7 @@ var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
 }, {
   rest(rest) {
     return this.clone({
@@ -22647,7 +22738,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodRecord.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
@@ -22689,7 +22780,7 @@ var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodMap.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
   inst.min = (...args) => inst.check(_minSize(...args));
@@ -22709,7 +22800,7 @@ var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
   inst.min = (...args) => inst.check(_minSize(...args));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
   inst.max = (...args) => inst.check(_maxSize(...args));
@@ -22725,7 +22816,7 @@ function set(valueType, params) {
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
   inst.enum = def.entries;
   inst.options = [...inst._zod.values];
   const keys = new Set(Object.keys(def.entries));
@@ -22761,24 +22852,24 @@ 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)
   });
 }
 var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
   $ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
   inst.values = new Set(def.values);
   Object.defineProperty(inst, "value", {
     get() {
@@ -22799,7 +22890,7 @@ function literal(value, params) {
 var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   $ZodFile.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
   inst.min = (size2, params) => inst.check(_minSize(size2, params));
   inst.max = (size2, params) => inst.check(_maxSize(size2, params));
   inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
@@ -22811,7 +22902,7 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -22850,7 +22941,7 @@ function transform(fn) {
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -22862,7 +22953,7 @@ function optional(innerType) {
 var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -22874,7 +22965,7 @@ function exactOptional(innerType) {
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -22889,7 +22980,7 @@ function nullish2(innerType) {
 var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -22905,7 +22996,7 @@ function _default2(innerType, defaultValue) {
 var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -22920,7 +23011,7 @@ function prefault(innerType, defaultValue) {
 var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -22933,7 +23024,7 @@ function nonoptional(innerType, params) {
 var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
   $ZodSuccess.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function success(innerType) {
@@ -22945,7 +23036,7 @@ function success(innerType) {
 var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -22959,7 +23050,7 @@ function _catch2(innerType, catchValue) {
 var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
   $ZodNaN.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
 });
 function nan(params) {
   return _nan(ZodNaN, params);
@@ -22967,7 +23058,7 @@ function nan(params) {
 var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -23009,7 +23100,7 @@ var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) =>
 var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -23021,7 +23112,7 @@ function readonly(innerType) {
 var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
 });
 function templateLiteral(parts, params) {
   return new ZodTemplateLiteral({
@@ -23033,7 +23124,7 @@ function templateLiteral(parts, params) {
 var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -23045,7 +23136,7 @@ function lazy(getter) {
 var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
   $ZodPromise.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function promise(innerType) {
@@ -23057,7 +23148,7 @@ function promise(innerType) {
 var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
   $ZodFunction.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
 });
 function _function(params) {
   return new ZodFunction({
@@ -23069,7 +23160,7 @@ function _function(params) {
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
 });
 function check(fn) {
   const ch = new $ZodCheck({
@@ -24158,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
@@ -24170,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",
@@ -24221,25 +24312,39 @@ var RULES = [
     replace: "[REDACTED_TOKEN]"
   }
 ];
-function currentUserPattern() {
-  let name;
+var COMMON_NAMES = /* @__PURE__ */ new Set([
+  // System, CI and container accounts
+  ...["root", "admin", "administrator", "user", "guest", "test", "tester", "dev", "developer", "build", "builder"],
+  ...["runner", "deploy", "app", "node", "git", "www", "web", "server", "ubuntu", "debian", "centos", "fedora"],
+  ...["alpine", "vagrant", "docker", "jenkins", "codespace", "vscode", "coder", "gitpod", "default", "owner"],
+  ...["local", "home", "work", "ops", "operator", "service", "bot", "agent", "demo", "sandbox", "main", "master"],
+  // Given names that are also everyday words
+  ...["will", "mark", "max", "bill", "rob", "pat", "sue", "may", "june", "april", "august", "art", "grant"],
+  ...["hunter", "chase", "rose", "frank", "gene", "ray", "jack", "joy", "hope", "grace", "dawn", "summer", "guy"]
+]);
+function currentUserName() {
   try {
-    name = process.env.REFLEX_REDACT_USER ?? userInfo().username;
+    return process.env.REFLEX_REDACT_USER ?? userInfo().username;
   } catch {
-    name = void 0;
+    return void 0;
   }
-  if (!name || name.length < 3) return void 0;
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`\\b${escaped}\\b`, "gi");
 }
-var userPattern = currentUserPattern();
-function redactionFingerprint() {
-  let name = "";
-  try {
-    name = process.env.REFLEX_REDACT_USER ?? userInfo().username;
-  } catch {
-    name = "";
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function userRules() {
+  const rules2 = [];
+  const name = currentUserName();
+  const homeFolder = homedir().replace(/[\\/]+$/, "");
+  if (homeFolder.length >= 2) {
+    rules2.push({ name: "home", pattern: new RegExp(`(?<![\\w.-])${escapeRegExp(homeFolder)}(?![\\w.-])`, "g"), replace: "~" });
+  }
+  if (name && name.length >= 3 && !COMMON_NAMES.has(name.toLowerCase())) {
+    rules2.push({ name: "username", pattern: new RegExp(`\\b${escapeRegExp(name)}\\b`, "gi"), replace: "<user>" });
   }
+  return rules2;
+}
+var USER_RULES = userRules();
+function redactionFingerprint() {
+  const name = currentUserName() ?? "";
   return createHash2("sha256").update(`${name}
 ${homedir()}`).digest("hex").slice(0, 16);
 }
@@ -24254,37 +24359,34 @@ function redactDeep(value) {
 function redactWithReport(input2) {
   let text = input2;
   let redactions = 0;
-  const rules = /* @__PURE__ */ new Set();
-  for (const rule of RULES) {
+  const rules2 = /* @__PURE__ */ new Set();
+  for (const rule of [...RULES, ...USER_RULES]) {
     text = text.replace(rule.pattern, (...args) => {
       redactions++;
-      rules.add(rule.name);
+      rules2.add(rule.name);
       if (typeof rule.replace === "string") return rule.replace;
       const offsetIndex = args.findIndex((a) => typeof a === "number");
       const groups = args.slice(0, offsetIndex).map((a) => typeof a === "string" ? a : "");
       return rule.replace(...groups);
     });
   }
-  if (userPattern) {
-    text = text.replace(userPattern, () => {
-      redactions++;
-      rules.add("username");
-      return "<user>";
-    });
-  }
-  return { text, redactions, rules: [...rules] };
+  return { text, redactions, rules: [...rules2] };
 }
 function redact(input2) {
   return redactWithReport(input2).text;
 }
-var PATH_RULES = /* @__PURE__ */ new Set(["macos-home", "linux-home", "windows-home", "encoded-home", "email"]);
+var PATH_RULES = /* @__PURE__ */ new Set(["macos-home", "linux-home", "windows-home", "encoded-home", "email", "home", "username"]);
 function redactPath(input2) {
   let text = input2;
-  for (const rule of RULES) {
+  for (const rule of [...RULES, ...USER_RULES]) {
     if (!PATH_RULES.has(rule.name) || typeof rule.replace !== "string") continue;
     text = text.replace(rule.pattern, rule.replace);
   }
-  return userPattern ? text.replace(userPattern, "<user>") : text;
+  return text;
+}
+var REDACT_MARGIN = 1024;
+function redactTruncated(input2, max) {
+  return redact(input2.slice(0, max + REDACT_MARGIN)).slice(0, max);
 }
 function excerpt(input2, maxLength = 160) {
   const flat = redact(input2).replace(/\s+/g, " ").trim();
@@ -24385,6 +24487,47 @@ async function replaceOwnedFile(path, content, mode = 420) {
   }
 }
 
+// ../../packages/safety/src/spawn.ts
+import { statSync } from "node:fs";
+import { posix, win32 } from "node:path";
+var isFile = (path) => {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+};
+function findOnPath(name, host = {}) {
+  const env = host.env ?? process.env;
+  const exists2 = host.isFile ?? isFile;
+  if ((host.platform ?? process.platform) !== "win32") {
+    for (const dir of (env.PATH ?? "").split(posix.delimiter)) if (dir && exists2(posix.join(dir, name))) return posix.join(dir, name);
+    return void 0;
+  }
+  const exts = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").toLowerCase().split(";").filter(Boolean);
+  const names = exts.some((e2) => name.toLowerCase().endsWith(e2)) ? [name] : exts.map((e2) => name + e2);
+  for (const dir of (env.Path ?? env.PATH ?? "").split(win32.delimiter)) {
+    if (!dir) continue;
+    for (const n of names) if (exists2(win32.join(dir, n))) return win32.join(dir, n);
+  }
+  return void 0;
+}
+var UNSAFE_FOR_CMD = /["%\r\n\0]/;
+function agentLaunch(command, args, host = {}) {
+  if ((host.platform ?? process.platform) !== "win32") return { command, args };
+  const path = findOnPath(command, host);
+  if (!path) return { command, args };
+  if (!/\.(cmd|bat)$/i.test(path)) return { command: path, args };
+  if ([path, ...args].some((a) => UNSAFE_FOR_CMD.test(a))) {
+    throw new Error(
+      `${win32.basename(path)} is a Windows batch launcher, which can't be given quotes, % or line breaks safely. Leave them out, or install ${command} as an .exe.`
+    );
+  }
+  const line2 = [path, ...args].map((a) => `"${a.replace(/(\\+)$/, "$1$1")}"`).join(" ");
+  const env = host.env ?? process.env;
+  return { command: env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/v:off", "/c", `"${line2}"`], windowsVerbatimArguments: true };
+}
+
 // ../../packages/adapters/src/jsonl.ts
 import { createReadStream } from "node:fs";
 import { createInterface as createInterface2 } from "node:readline";
@@ -24392,19 +24535,19 @@ var MAX_LINE_BYTES = 4 * 1024 * 1024;
 async function* readJsonl(path) {
   const stream = createReadStream(path, { encoding: "utf8" });
   const rl = createInterface2({ input: stream, crlfDelay: Infinity });
-  let line = 0;
+  let line2 = 0;
   try {
     for await (const raw of rl) {
-      line++;
+      line2++;
       if (!raw.trim()) continue;
       if (raw.length > MAX_LINE_BYTES) {
-        yield { line, error: "too-large" };
+        yield { line: line2, error: "too-large" };
         continue;
       }
       try {
-        yield { line, value: JSON.parse(raw) };
+        yield { line: line2, value: JSON.parse(raw) };
       } catch {
-        yield { line, error: "invalid-json" };
+        yield { line: line2, error: "invalid-json" };
       }
     }
   } finally {
@@ -24422,10 +24565,10 @@ var MAX_REQUEST_CHARS = 2e3;
 var MAX_COMMAND_CHARS = 600;
 var MAX_ASSISTANT_CHARS = 400;
 var clean = {
-  request: (text) => redact(text.slice(0, MAX_REQUEST_CHARS)).trim(),
-  command: (text) => redact(text.slice(0, MAX_COMMAND_CHARS)).trim(),
-  assistant: (text) => redact(text.slice(0, MAX_ASSISTANT_CHARS)).trim(),
-  path: (text) => redact(text.slice(0, 400))
+  request: (text) => redactTruncated(text, MAX_REQUEST_CHARS).trim(),
+  command: (text) => redactTruncated(text, MAX_COMMAND_CHARS).trim(),
+  assistant: (text) => redactTruncated(text, MAX_ASSISTANT_CHARS).trim(),
+  path: (text) => redactTruncated(text, 400)
 };
 function isHarnessText(text) {
   const t = text.trimStart();
@@ -24444,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) {
@@ -24647,13 +24790,13 @@ var ClaudeCodeAdapter = class {
     let skippedRecords = 0;
     const fallbackId = basename2(file2.path, ".jsonl");
     try {
-      for await (const line of readJsonl(file2.path)) {
+      for await (const line2 of readJsonl(file2.path)) {
         totalRecords++;
-        if (line.error) {
+        if (line2.error) {
           skippedRecords++;
           continue;
         }
-        const parsed = ClaudeRecord.safeParse(line.value);
+        const parsed = ClaudeRecord.safeParse(line2.value);
         if (!parsed.success) {
           skippedRecords++;
           continue;
@@ -24835,27 +24978,27 @@ var CodexAdapter = class {
     const eventUserMessages = [];
     let model2;
     try {
-      for await (const line of readJsonl(file2.path)) {
+      for await (const line2 of readJsonl(file2.path)) {
         totalRecords++;
-        if (line.error) {
+        if (line2.error) {
           skippedRecords++;
           continue;
         }
-        const wrapped = RolloutLine.safeParse(line.value);
+        const wrapped = RolloutLine.safeParse(line2.value);
         if (!wrapped.success) {
           skippedRecords++;
           continue;
         }
         const at = wrapped.data.timestamp;
         const kind = wrapped.data.type;
-        const body = wrapped.data.payload ?? line.value;
+        const body = wrapped.data.payload ?? line2.value;
         b3.touch(at);
         if (kind === "session_meta") {
-          const meta3 = Item.safeParse({ type: "session_meta", ...body });
-          if (meta3.success) {
-            if (meta3.data.id) b3.nativeId = meta3.data.id.slice(0, 80);
-            if (meta3.data.cwd) b3.cwd = meta3.data.cwd;
-            b3.touch(meta3.data.timestamp);
+          const meta4 = Item.safeParse({ type: "session_meta", ...body });
+          if (meta4.success) {
+            if (meta4.data.id) b3.nativeId = meta4.data.id.slice(0, 80);
+            if (meta4.data.cwd) b3.cwd = meta4.data.cwd;
+            b3.touch(meta4.data.timestamp);
           }
           continue;
         }
@@ -24951,7 +25094,7 @@ var CodexAdapter = class {
 };
 
 // ../../packages/adapters/src/cursor.ts
-import { existsSync, statSync } from "node:fs";
+import { existsSync, statSync as statSync2 } from "node:fs";
 import { lstat as lstat3, readdir as readdir2 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
 import { basename as basename4, dirname as dirname2, join as join6 } from "node:path";
@@ -25014,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({
@@ -25042,7 +25274,7 @@ var MAX_AGENT_TRANSCRIPTS = 300;
 async function agentTranscripts(chatFile) {
   return listFiles(join6(dirname2(chatFile), "subagents"), ".jsonl", 0);
 }
-async function isFile(path) {
+async function isFile2(path) {
   try {
     return (await lstat3(path)).isFile();
   } catch {
@@ -25070,7 +25302,7 @@ function decodeWorkspace(encoded, root = "/") {
       budget--;
       const candidate = join6(dir, tokens2.slice(i, j2).join("-"));
       try {
-        if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+        if (existsSync(candidate) && statSync2(candidate).isDirectory()) {
           const found = walk(candidate, j2);
           if (found) return found;
         }
@@ -25089,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() {
@@ -25122,11 +25365,11 @@ var CursorAdapter = class {
   }
   async requestPermission(ask2, days) {
     if (!await ask2(`Read Cursor agent sessions from the last ${days} day${days === 1 ? "" : "s"} at ${displayPath(this.root)}?`)) return false;
-    if (this.stateDb && await isFile(this.stateDb)) {
-      const allowed = await ask2(
+    if (this.stateDb && await isFile2(this.stateDb)) {
+      const allowed2 = await ask2(
         `Also read which model each Cursor chat used, from Cursor's app database at ${displayPath(this.stateDb)}? Read-only; only model names are extracted, never messages.`
       );
-      if (allowed) this.models = new CursorModelIndex(this.stateDb);
+      if (allowed2) this.models = new CursorModelIndex(this.stateDb);
     }
     return true;
   }
@@ -25150,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;
@@ -25194,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);
@@ -25205,13 +25458,13 @@ var CursorAdapter = class {
   }
   /** Streams a transcript's user and assistant content blocks; malformed lines and blocks are counted and skipped. */
   async readBlocks(path, b3, counts, onBlock) {
-    for await (const line of readJsonl(path)) {
+    for await (const line2 of readJsonl(path)) {
       counts.total++;
-      if (line.error) {
+      if (line2.error) {
         counts.skipped++;
         continue;
       }
-      const parsed = CursorRecord.safeParse(line.value);
+      const parsed = CursorRecord.safeParse(line2.value);
       if (!parsed.success) {
         counts.skipped++;
         continue;
@@ -25801,7 +26054,7 @@ function bigrams(stems) {
 }
 var BIGRAM_BLEND = 0.3;
 function termSimilarities(termLists, weights) {
-  const stems = termLists.map((terms) => terms.map(stem));
+  const stems = termLists.map((terms2) => terms2.map(stem));
   const words2 = buildTfIdf(stems, weights && new Map([...weights].map(([t, w2]) => [stem(t), w2]))).vectors;
   const pairs = buildTfIdf(stems.map(bigrams)).vectors;
   return (i, j2) => {
@@ -25829,9 +26082,9 @@ var CONCEPT_WORDS = {
 var CONCEPT_OF = /* @__PURE__ */ new Map();
 var DEVELOPER_WORDS = /* @__PURE__ */ new Set([...Object.values(CONCEPT_WORDS).flat(), ...Object.values(CANONICAL)]);
 for (const [concept, words2] of Object.entries(CONCEPT_WORDS)) for (const w2 of words2) CONCEPT_OF.set(w2, concept);
-function concepts(terms) {
+function concepts(terms2) {
   const v2 = /* @__PURE__ */ new Map();
-  for (const t of terms) {
+  for (const t of terms2) {
     const c2 = t.startsWith("@") ? "dependency" : CONCEPT_OF.get(t) ?? CONCEPT_OF.get(stem(t));
     if (c2) v2.set(c2, (v2.get(c2) ?? 0) + 1);
   }
@@ -25846,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;
     }
@@ -25879,24 +26132,33 @@ var WEIGHTS = {
   repository: 0.05
 };
 function jaccard(a, b3) {
-  const A3 = new Set(a);
-  const B2 = new Set(b3);
+  return setJaccard(new Set(a), new Set(b3));
+}
+function setJaccard(A3, B2) {
   if (!A3.size && !B2.size) return 0;
   let inter = 0;
   for (const x2 of A3) if (B2.has(x2)) inter++;
   return inter / (A3.size + B2.size - inter);
 }
+var lcsRows = new Int32Array(0);
 function lcsLength(a, b3) {
   if (!a.length || !b3.length) return 0;
-  let prev = new Array(b3.length + 1).fill(0);
+  const width = b3.length + 1;
+  if (lcsRows.length < 2 * width) lcsRows = new Int32Array(2 * width);
+  const rows2 = lcsRows;
+  let prev = 0;
+  let cur = width;
+  rows2.fill(0, prev, prev + width);
   for (let i = 1; i <= a.length; i++) {
-    const cur = new Array(b3.length + 1).fill(0);
+    rows2[cur] = 0;
     for (let j2 = 1; j2 <= b3.length; j2++) {
-      cur[j2] = a[i - 1] === b3[j2 - 1] ? prev[j2 - 1] + 1 : Math.max(prev[j2], cur[j2 - 1]);
+      rows2[cur + j2] = a[i - 1] === b3[j2 - 1] ? rows2[prev + j2 - 1] + 1 : Math.max(rows2[prev + j2], rows2[cur + j2 - 1]);
     }
+    const done = prev;
     prev = cur;
+    cur = done;
   }
-  return prev[b3.length];
+  return rows2[prev + b3.length];
 }
 var COARSE = {
   "inspect-git": "git",
@@ -25920,16 +26182,21 @@ var COARSE = {
 function collapse(seq) {
   return seq.filter((s, i) => i === 0 || seq[i - 1] !== s);
 }
+var steps = (seq) => ({ seq, set: new Set(seq) });
+function actionShape(sequence) {
+  const fine = sequence.filter((s) => s !== "summarize");
+  return { fine: steps(fine), coarse: steps(collapse(fine.map((v2) => COARSE[v2] ?? v2))) };
+}
 function sequenceAgreement(x2, y3) {
-  if (!x2.length || !y3.length) return 0;
-  const lcs = 2 * lcsLength(x2, y3) / (x2.length + y3.length);
-  return 0.5 * lcs + 0.5 * jaccard(x2, y3);
+  if (!x2.seq.length || !y3.seq.length) return 0;
+  const lcs = 2 * lcsLength(x2.seq, y3.seq) / (x2.seq.length + y3.seq.length);
+  return 0.5 * lcs + 0.5 * setJaccard(x2.set, y3.set);
+}
+function shapeSimilarity(a, b3) {
+  return 0.5 * sequenceAgreement(a.fine, b3.fine) + 0.5 * sequenceAgreement(a.coarse, b3.coarse);
 }
 function actionSimilarity(a, b3) {
-  const x2 = a.filter((s) => s !== "summarize");
-  const y3 = b3.filter((s) => s !== "summarize");
-  const coarse = (s) => collapse(s.map((v2) => COARSE[v2] ?? v2));
-  return 0.5 * sequenceAgreement(x2, y3) + 0.5 * sequenceAgreement(coarse(x2), coarse(y3));
+  return shapeSimilarity(actionShape(a), actionShape(b3));
 }
 function opKeys(t) {
   const keys = new Set(t.commands.map(opKey));
@@ -25941,12 +26208,15 @@ function opKeys(t) {
   keys.delete("");
   return keys;
 }
-function similarity(a, b3, intentScore, keysA = opKeys(a), keysB = opKeys(b3)) {
+function traceFeatures(t) {
+  return { actions: actionShape(t.actionSequence), keys: opKeys(t), files: new Set(t.fileCategories) };
+}
+function similarity(a, b3, intentScore, fa = traceFeatures(a), fb = traceFeatures(b3)) {
   const parts = {
     intent: intentScore,
-    actions: actionSimilarity(a.actionSequence, b3.actionSequence),
-    commands: jaccard(keysA, keysB),
-    files: jaccard(a.fileCategories, b3.fileCategories),
+    actions: shapeSimilarity(fa.actions, fb.actions),
+    commands: setJaccard(fa.keys, fb.keys),
+    files: setJaccard(fa.files, fb.files),
     repository: a.projectHash && a.projectHash === b3.projectHash ? 1 : 0
   };
   const total = WEIGHTS.intent * parts.intent + WEIGHTS.actions * parts.actions + WEIGHTS.commands * parts.commands + WEIGHTS.files * parts.files + WEIGHTS.repository * parts.repository;
@@ -26040,8 +26310,11 @@ function render(polarity, ws) {
   return polarity === "avoid" ? `Don't ${phrase}.` : `${phrase[0].toUpperCase()}${phrase.slice(1)}.`;
 }
 function recurringCorrections(perInstance) {
+  return recurringCorrectionsBySession(perInstance).map(({ instances: _3, ...c2 }) => c2);
+}
+function recurringCorrectionsBySession(perInstance) {
   const items = perInstance.flatMap((cs, inst) => cs.map((c2) => ({ ...c2, inst, keys: matchKeys(c2.words) })));
-  const rules = /* @__PURE__ */ new Map();
+  const rules2 = /* @__PURE__ */ new Map();
   for (let i = 0; i < items.length; i++) {
     for (let j2 = i + 1; j2 < items.length; j2++) {
       const a = items[i];
@@ -26051,16 +26324,16 @@ function recurringCorrections(perInstance) {
       const shared = a.words.filter((_3, k3) => other.has(a.keys[k3]));
       if (!wellFormed(a.polarity, shared)) continue;
       const id = `${a.polarity}:${shared.join(" ")}`;
-      const rule = rules.get(id) ?? { polarity: a.polarity, words: shared, sessions: /* @__PURE__ */ new Set() };
+      const rule = rules2.get(id) ?? { polarity: a.polarity, words: shared, sessions: /* @__PURE__ */ new Set() };
       rule.sessions.add(a.inst).add(b3.inst);
-      rules.set(id, rule);
+      rules2.set(id, rule);
     }
   }
-  const all = [...rules.values()];
+  const all = [...rules2.values()];
   const covered = (r2) => all.some(
     (s) => s !== r2 && s.polarity === r2.polarity && s.words.length < r2.words.length && s.words.every((w2) => r2.words.includes(w2)) && [...r2.sessions].every((x2) => s.sessions.has(x2))
   );
-  return all.filter((r2) => !covered(r2)).map((r2) => ({ polarity: r2.polarity, text: render(r2.polarity, r2.words), sessions: r2.sessions.size })).sort((a, b3) => b3.sessions - a.sessions || a.text.localeCompare(b3.text));
+  return all.filter((r2) => !covered(r2)).map((r2) => ({ polarity: r2.polarity, text: render(r2.polarity, r2.words), sessions: r2.sessions.size, instances: [...r2.sessions].sort((a, b3) => a - b3) })).sort((a, b3) => b3.sessions - a.sessions || a.text.localeCompare(b3.text));
 }
 
 // ../../packages/analysis/src/context.ts
@@ -26068,12 +26341,12 @@ function withFloor(vectors, floor) {
   return Object.assign(vectors, { floor });
 }
 var CONTEXT_CHARS = 2e3;
-function isNoiseLine(line) {
-  return /^\s*at\s/.test(line) || /\d{4}-\d\d-\d\dT\d\d:\d\d/.test(line) || /^\s*[✓✗✔✘×√]\s/.test(line) || /^\s*\[[\w-]+\]/.test(line) || // Mostly digits and symbols. Letters of any script count, so non-English text is never noise.
-  line.length > 30 && (line.match(new RegExp("\\p{L}{2,}", "gu")) ?? []).join("").length / line.length < 0.4;
+function isNoiseLine(line2) {
+  return /^\s*at\s/.test(line2) || /\d{4}-\d\d-\d\dT\d\d:\d\d/.test(line2) || /^\s*[✓✗✔✘×√]\s/.test(line2) || /^\s*\[[\w-]+\]/.test(line2) || // Mostly digits and symbols. Letters of any script count, so non-English text is never noise.
+  line2.length > 30 && (line2.match(new RegExp("\\p{L}{2,}", "gu")) ?? []).join("").length / line2.length < 0.4;
 }
 function requestWords(text) {
-  const kept = text.replace(/```[\s\S]*?(```|$)/g, " ").split("\n").filter((line) => !isNoiseLine(line)).join("\n").replace(/\bat [\w.<>$]+ \([^)]*:\d+:\d+\)/g, " ").trim();
+  const kept = text.replace(/```[\s\S]*?(```|$)/g, " ").split("\n").filter((line2) => !isNoiseLine(line2)).join("\n").replace(/\bat [\w.<>$]+ \([^)]*:\d+:\d+\)/g, " ").trim();
   return kept || text;
 }
 function contextDocument(t, request) {
@@ -26122,8 +26395,8 @@ function usedSkill(trace, name) {
   return (trace.skillsUsed ?? []).some((s) => s === name || s.endsWith(`:${name}`));
 }
 function buildTrace(session) {
-  const steps = [];
-  const commands = [];
+  const steps2 = [];
+  const commands2 = [];
   const tools = /* @__PURE__ */ new Set();
   const fileCategories = /* @__PURE__ */ new Set();
   const eventHashes = [];
@@ -26140,8 +26413,8 @@ function buildTrace(session) {
         tools.add("shell");
         for (const s of skillsIn(ev.command)) skills.add(s);
         for (const fp of classifyCommand(ev.command)) {
-          commands.push(ev.isError ? { ...fp, failed: true } : fp);
-          steps.push({ action: fp.action, isError: ev.isError, command: fp });
+          commands2.push(ev.isError ? { ...fp, failed: true } : fp);
+          steps2.push({ action: fp.action, isError: ev.isError, command: fp });
           show2(fp.normalized);
         }
         eventHashes.push(shortHash(`shell|${ev.at ?? ""}|${ev.command}`));
@@ -26152,7 +26425,7 @@ function buildTrace(session) {
         if (ev.op === "read") for (const s of skillsIn(ev.path)) skills.add(s);
         const category = fileCategory(ev.path);
         fileCategories.add(category);
-        steps.push({ action: fileAction(ev.op, category), isError: ev.isError });
+        steps2.push({ action: fileAction(ev.op, category), isError: ev.isError });
         show2(`${ev.op === "read" ? "read" : "edit"} ${FILE_LABEL[category]}`);
         eventHashes.push(shortHash(`file|${ev.at ?? ""}|${ev.op}|${ev.path}`));
         break;
@@ -26162,7 +26435,7 @@ function buildTrace(session) {
         if (ev.skill) skills.add(ev.skill);
         const action = TOOL_ACTIONS[ev.tool];
         if (action) {
-          steps.push({ action, isError: ev.isError });
+          steps2.push({ action, isError: ev.isError });
           show2(action === "search-code" ? "search code" : "look up docs");
         }
         break;
@@ -26174,14 +26447,14 @@ function buildTrace(session) {
         break;
     }
   }
-  for (const fp of commands) {
+  for (const fp of commands2) {
     if (fp.action === "inspect-ci") fileCategories.add("ci-config");
     if (fp.action === "inspect-dependencies" && /<file>/.test(fp.normalized)) fileCategories.add("dependency-manifest");
   }
   const lastAssistant = [...session.events].reverse().find((e2) => e2.kind !== "error");
   const summarized = lastAssistant?.kind === "assistant";
   const actionSequence = [];
-  for (const s of steps) {
+  for (const s of steps2) {
     if (actionSequence[actionSequence.length - 1] !== s.action) actionSequence.push(s.action);
   }
   if (summarized) actionSequence.push("summarize");
@@ -26200,11 +26473,11 @@ function buildTrace(session) {
     projectHash: session.project?.pathHash,
     intents,
     tools: [...tools].sort(),
-    commands,
+    commands: commands2,
     fileCategories: [...fileCategories].sort(),
     actionSequence: actionSequence.slice(0, MAX_SEQUENCE),
     displaySteps,
-    outcome: outcomeOf(steps, summarized),
+    outcome: outcomeOf(steps2, summarized),
     excerpt: excerpt(session.requests[0]?.text ?? "", 180),
     fingerprint,
     eventHashes,
@@ -26237,14 +26510,14 @@ function summarizeAgents(session) {
     toolCalls: session.events.filter((e2) => (e2.kind === "shell" || e2.kind === "file" || e2.kind === "tool") && e2.byAgent).length
   };
 }
-function outcomeOf(steps, summarized) {
+function outcomeOf(steps2, summarized) {
   let lastModify = -1;
-  steps.forEach((s, i) => {
+  steps2.forEach((s, i) => {
     if (MODIFY_ACTIONS.has(s.action)) lastModify = i;
   });
-  const verified = steps.some((s, i) => i > lastModify && VERIFY_ACTIONS.has(s.action) && !s.isError);
-  const failedAt = steps.findIndex((s) => s.isError);
-  const recoveredFromFailure = failedAt >= 0 && steps.slice(failedAt + 1).some((s) => VERIFY_ACTIONS.has(s.action) && !s.isError);
+  const verified = steps2.some((s, i) => i > lastModify && VERIFY_ACTIONS.has(s.action) && !s.isError);
+  const failedAt = steps2.findIndex((s) => s.isError);
+  const recoveredFromFailure = failedAt >= 0 && steps2.slice(failedAt + 1).some((s) => VERIFY_ACTIONS.has(s.action) && !s.isError);
   return { verified, recoveredFromFailure, modified: lastModify >= 0, summarized };
 }
 function isGenericTrace(trace) {
@@ -26362,6 +26635,30 @@ function fillerWeights(traces) {
 var CLUSTER_THRESHOLD = 0.45;
 var MIN_INTENT_COHESION = 0.2;
 var MIN_INTENT_LINK = 0.35;
+var PairMatrix = class _PairMatrix {
+  constructor(size2) {
+    this.size = size2;
+    this.values = new Float64Array(size2 * (size2 - 1) / 2);
+  }
+  size;
+  values;
+  index(i, j2) {
+    const a = i < j2 ? i : j2;
+    const b3 = i < j2 ? j2 : i;
+    return a * (2 * this.size - a - 1) / 2 + b3 - a - 1;
+  }
+  get(i, j2) {
+    return i === j2 ? 1 : this.values[this.index(i, j2)];
+  }
+  set(i, j2, value) {
+    this.values[this.index(i, j2)] = value;
+  }
+  copy() {
+    const m2 = new _PairMatrix(this.size);
+    m2.values.set(this.values);
+    return m2;
+  }
+};
 var EMBEDDING_FLOOR = 0.05;
 function rescaleEmbedding(cos, floor = EMBEDDING_FLOOR) {
   return Math.min(1, Math.max(0, (cos - floor) / (1 - floor)));
@@ -26382,21 +26679,15 @@ function intentSimilarities(traces, vectors) {
 }
 function similarityMatrices(traces, vectors) {
   const intentOf = intentSimilarities(traces, vectors);
-  const keys = traces.map(opKeys);
+  const features = traces.map(traceFeatures);
   const n = traces.length;
-  const make = () => Array.from({ length: n }, () => new Array(n).fill(1));
-  const m2 = { total: make(), intent: make(), actions: make() };
+  const m2 = { total: new PairMatrix(n), intent: new PairMatrix(n), actions: new PairMatrix(n) };
   for (let i = 0; i < n; i++) {
     for (let j2 = i + 1; j2 < n; j2++) {
-      const s = similarity(traces[i], traces[j2], intentOf(i, j2), keys[i], keys[j2]);
-      for (const [name, v2] of [
-        ["total", s.total],
-        ["intent", s.intent],
-        ["actions", s.actions]
-      ]) {
-        m2[name][i][j2] = v2;
-        m2[name][j2][i] = v2;
-      }
+      const s = similarity(traces[i], traces[j2], intentOf(i, j2), features[i], features[j2]);
+      m2.total.set(i, j2, s.total);
+      m2.intent.set(i, j2, s.intent);
+      m2.actions.set(i, j2, s.actions);
     }
   }
   return m2;
@@ -26406,7 +26697,7 @@ function meanPairwise(matrix, members2) {
   let pairs = 0;
   for (let x2 = 0; x2 < members2.length; x2++)
     for (let y3 = x2 + 1; y3 < members2.length; y3++) {
-      total += matrix[members2[x2]][members2[y3]];
+      total += matrix.get(members2[x2], members2[y3]);
       pairs++;
     }
   return pairs ? total / pairs : 1;
@@ -26415,37 +26706,56 @@ function clusterTraces(traces, threshold = CLUSTER_THRESHOLD, vectors, minIntent
   const sim = similarityMatrices(traces, vectors);
   const n = traces.length;
   const members2 = traces.map((_3, i) => [i]);
-  const link = sim.total.map((row) => [...row]);
-  const intentLink = sim.intent.map((row) => [...row]);
+  const link = sim.total.copy();
+  const intentLink = sim.intent.copy();
+  const bestJ = new Int32Array(n).fill(-1);
+  const bestLink = new Float64Array(n).fill(-1);
+  const findBest = (i) => {
+    bestJ[i] = -1;
+    bestLink[i] = -1;
+    for (let j2 = i + 1; j2 < n; j2++) {
+      if (!members2[j2] || intentLink.get(i, j2) < minIntent) continue;
+      const v2 = link.get(i, j2);
+      if (v2 > bestLink[i]) {
+        bestLink[i] = v2;
+        bestJ[i] = j2;
+      }
+    }
+  };
+  for (let i = 0; i < n; i++) findBest(i);
   for (; ; ) {
     let best = -1;
     let bi = -1;
-    let bj = -1;
     for (let i = 0; i < n; i++) {
-      if (!members2[i]) continue;
-      for (let j2 = i + 1; j2 < n; j2++) {
-        if (!members2[j2] || intentLink[i][j2] < minIntent) continue;
-        if (link[i][j2] > best) {
-          best = link[i][j2];
-          bi = i;
-          bj = j2;
-        }
+      if (members2[i] && bestJ[i] >= 0 && bestLink[i] > best) {
+        best = bestLink[i];
+        bi = i;
       }
     }
     if (bi < 0 || best < threshold) break;
+    const bj = bestJ[bi];
     const a = members2[bi];
     const b3 = members2[bj];
     for (let k3 = 0; k3 < n; k3++) {
       if (!members2[k3] || k3 === bi || k3 === bj) continue;
-      const v2 = (a.length * link[bi][k3] + b3.length * link[bj][k3]) / (a.length + b3.length);
-      link[bi][k3] = v2;
-      link[k3][bi] = v2;
-      const w2 = (a.length * intentLink[bi][k3] + b3.length * intentLink[bj][k3]) / (a.length + b3.length);
-      intentLink[bi][k3] = w2;
-      intentLink[k3][bi] = w2;
+      link.set(bi, k3, (a.length * link.get(bi, k3) + b3.length * link.get(bj, k3)) / (a.length + b3.length));
+      intentLink.set(bi, k3, (a.length * intentLink.get(bi, k3) + b3.length * intentLink.get(bj, k3)) / (a.length + b3.length));
     }
     members2[bi] = [...a, ...b3].sort((x2, y3) => x2 - y3);
     members2[bj] = null;
+    bestJ[bj] = -1;
+    findBest(bi);
+    for (let k3 = 0; k3 < bj; k3++) {
+      if (!members2[k3] || k3 === bi) continue;
+      if (bestJ[k3] === bi || bestJ[k3] === bj) findBest(k3);
+      else if (k3 < bi && intentLink.get(k3, bi) >= minIntent) {
+        const v2 = link.get(k3, bi);
+        if (v2 > bestLink[k3] || v2 === bestLink[k3] && bi < bestJ[k3]) {
+          bestLink[k3] = v2;
+          bestJ[k3] = bi;
+        }
+      }
+    }
   }
   return members2.filter((m2) => m2 !== null).map((m2) => ({
     members: m2,
@@ -26698,15 +27008,15 @@ function stepOrder(inst) {
   return at;
 }
 var LAST_OCCURRENCE = /* @__PURE__ */ new Set(["run-tests", "run-build", "run-lint", "inspect-diff"]);
-function completionCriteria(steps) {
+function completionCriteria(steps2) {
   const out2 = [];
-  if (steps.has("inspect-ci")) out2.push("The CI-equivalent command succeeds locally where it can be reproduced.");
-  if (steps.has("run-tests")) out2.push("Relevant tests pass.");
-  if (steps.has("run-build")) out2.push("Build or typecheck succeeds.");
-  if (steps.has("run-lint")) out2.push("Linter passes.");
-  if (steps.has("inspect-diff") || steps.has("inspect-git")) out2.push("Repository state and the final diff have been reviewed; the diff contains only intended changes.");
-  if (steps.has("submit-review")) out2.push("The review is posted with concrete findings, or explicitly states that none were found.");
-  if (steps.has("summarize")) out2.push("A summary states the root cause (or findings), what changed, and how it was verified.");
+  if (steps2.has("inspect-ci")) out2.push("The CI-equivalent command succeeds locally where it can be reproduced.");
+  if (steps2.has("run-tests")) out2.push("Relevant tests pass.");
+  if (steps2.has("run-build")) out2.push("Build or typecheck succeeds.");
+  if (steps2.has("run-lint")) out2.push("Linter passes.");
+  if (steps2.has("inspect-diff") || steps2.has("inspect-git")) out2.push("Repository state and the final diff have been reviewed; the diff contains only intended changes.");
+  if (steps2.has("submit-review")) out2.push("The review is posted with concrete findings, or explicitly states that none were found.");
+  if (steps2.has("summarize")) out2.push("A summary states the root cause (or findings), what changed, and how it was verified.");
   return out2;
 }
 function frequentTerms(instances, limit = 6) {
@@ -26770,15 +27080,15 @@ function analyze(traces, opts = {}) {
     if (cluster.members.length < MIN_INSTANCES) continue;
     if (cluster.intentCohesion < MIN_INTENT_COHESION || cluster.actionCohesion < MIN_ACTION_COHESION) continue;
     const group = cluster.members.map((i) => candidates[i]);
-    const steps = consensusSteps(group);
-    const stepKinds = new Set(steps.map((s) => s.kind));
+    const steps2 = consensusSteps(group);
+    const stepKinds = new Set(steps2.map((s) => s.kind));
     if (stepKinds.size - (stepKinds.has("summarize") ? 1 : 0) < 3) continue;
-    const terms = distinctiveTerms(group, context);
+    const terms2 = distinctiveTerms(group, context);
     const frequent = frequentTerms(group);
     const fileCats = new Set(group.flatMap((g2) => g2.primary.fileCategories));
     const family = FAMILIES.filter((f) => f.requires(stepKinds, fileCats)).map((f) => ({ f, score: f.terms.filter((t) => frequent.includes(t)).length })).filter((x2) => x2.score > 0).sort((a, b3) => b3.score - a.score)[0]?.f;
-    const fallbackTerms = terms.slice(0, 3);
-    const baseSlug = family?.slug ?? toSlug(fallbackTerms.join(" ") || steps.map((s) => s.kind).slice(0, 2).join(" "));
+    const fallbackTerms = terms2.slice(0, 3);
+    const baseSlug = family?.slug ?? toSlug(fallbackTerms.join(" ") || steps2.map((s) => s.kind).slice(0, 2).join(" "));
     const inside = /* @__PURE__ */ new Map();
     for (const g2 of group) for (const s of skillsOf(g2)) inside.set(s, (inside.get(s) ?? 0) + 1);
     const rest = Math.max(1, instances.length - group.length);
@@ -26808,13 +27118,13 @@ 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;
     const durations = group.map((g2) => g2.primary.startedAt && g2.primary.endedAt ? (Date.parse(g2.primary.endedAt) - Date.parse(g2.primary.startedAt)) / 6e4 : NaN).filter((m2) => Number.isFinite(m2) && m2 > 0);
-    const consensus = steps.reduce((acc, s) => acc + s.support, 0) / steps.length;
+    const consensus = steps2.reduce((acc, s) => acc + s.support, 0) / steps2.length;
     const confidence = 0.3 * Math.min(1, cluster.cohesion / 0.75) + 0.2 * Math.min(1, group.length / 6) + 0.15 * Math.min(1, repos.length / 3) + 0.2 * consensus + 0.15 * verifiedRate;
     const notes = [];
     if (repos.length === 1) notes.push("All evidence comes from a single repository; the skill may be repository-specific.");
@@ -26825,8 +27135,8 @@ function analyze(traces, opts = {}) {
     suggestions.push({
       slug,
       title: family?.title ?? `Repeated workflow: ${fallbackTerms.join(", ") || slug}`,
-      description: family?.description ?? `Repeated workflow involving ${steps.map((s) => s.label).slice(0, 3).join(", ")}.`,
-      whenToUse: family?.whenToUse ?? `Use for requests similar to: ${terms.slice(0, 5).join(", ")}.`,
+      description: family?.description ?? `Repeated workflow involving ${steps2.map((s) => s.label).slice(0, 3).join(", ")}.`,
+      whenToUse: family?.whenToUse ?? `Use for requests similar to: ${terms2.slice(0, 5).join(", ")}.`,
       confidence: Math.round(confidence * 100) / 100,
       cohesion: Math.round(cluster.cohesion * 100) / 100,
       instances: group.length,
@@ -26835,9 +27145,9 @@ function analyze(traces, opts = {}) {
       sources,
       firstSeen: dates[0],
       lastSeen: dates[dates.length - 1],
-      steps,
+      steps: steps2,
       completion: completionCriteria(stepKinds),
-      topTerms: terms,
+      topTerms: terms2,
       evidence: group.map((g2) => evidenceFor(g2, slug)).sort((a, b3) => (a.date ?? "").localeCompare(b3.date ?? "")),
       notes,
       verifiedRate: Math.round(verifiedRate * 100) / 100,
@@ -26974,8 +27284,8 @@ var requestDocument = (request) => contextDocument({ excerpt: "", fileCategories
 var DEFAULT_ROUTER_SETTINGS = { autopilot: false, explore: 0, protect: [] };
 function chooseRoute(guess, table2, opts) {
   const fallback = opts.sources[0] ?? "claude-code";
-  const allowed = (a) => opts.sources.includes(a.source);
-  const arms = (guess.kind ? table2.find((k3) => k3.kind.key === guess.kind.key)?.arms ?? [] : []).filter(allowed);
+  const allowed2 = (a) => opts.sources.includes(a.source);
+  const arms = (guess.kind ? table2.find((k3) => k3.kind.key === guess.kind.key)?.arms ?? [] : []).filter(allowed2);
   const p3 = pickArm(arms);
   const base = { guess, randomized: false, pick: p3.arm, arms };
   const explore = Math.min(MAX_EXPLORE, Math.max(0, opts.settings.explore));
@@ -27156,13 +27466,13 @@ function reviewSkill(skill, content, traces) {
     protected: fixed
   };
   if (n < MIN_REVIEW_SESSIONS) return { ...base, commands: [], missing: [], rarelyTaken: [], constraints: [] };
-  const steps = consensusSteps(instances).filter((s) => !GENERIC.has(s.kind) && MENTIONS[s.kind]);
-  const commands = steps.filter((s) => mentions(text, s.kind)).map((s) => ({ ...s, examples: s.examples.filter((e2) => !text.includes(e2.toLowerCase()) && !(s.kind.startsWith("inspect-") && WRITES.test(e2))) })).filter((s) => s.examples.length);
-  const missing = steps.filter((s) => !mentions(text, s.kind) && !(fixed.length && s.kind === "summarize"));
+  const steps2 = consensusSteps(instances).filter((s) => !GENERIC.has(s.kind) && MENTIONS[s.kind]);
+  const commands2 = steps2.filter((s) => mentions(text, s.kind)).map((s) => ({ ...s, examples: s.examples.filter((e2) => !text.includes(e2.toLowerCase()) && !(s.kind.startsWith("inspect-") && WRITES.test(e2))) })).filter((s) => s.examples.length);
+  const missing = steps2.filter((s) => !mentions(text, s.kind) && !(fixed.length && s.kind === "summarize"));
   const share = (kind) => runs.filter((t) => kind === "apply-fix" ? t.actionSequence.some((a) => a.startsWith("modify-")) : t.actionSequence.includes(kind)).length / n;
   const rarelyTaken = Object.keys(MENTIONS).filter((k3) => !GENERIC.has(k3) && !k3.startsWith("modify-") && k3 !== "summarize" && mentions(text, k3) && share(k3) < STALE_BELOW).map((k3) => ({ kind: k3, label: STEP_TEXT[k3].label, share: share(k3) })).sort((a, b3) => a.share - b3.share).slice(0, MAX_RARELY);
   const constraints = recurringCorrections(runs.map((t) => t.corrections ?? [])).filter(isSafeConstraint).filter((c2) => c2.text.toLowerCase().replace(/[^a-z\s-]/g, "").split(/\s+/).some((w2) => w2.length > 2 && !VAGUE.has(w2) && !/^(don't|dont|never|always|avoid|use|prefer|run|keep)$/.test(w2))).filter((c2) => !(fixed.length && OUTPUT_WORDS.test(c2.text))).filter((c2) => !c2.text.toLowerCase().split(/\s+/).every((w2) => w2.length < 3 || text.includes(w2))).slice(0, MAX_CONSTRAINTS2);
-  return { ...base, commands, model: modelAdvice(runs), missing, rarelyTaken, constraints };
+  return { ...base, commands: commands2, model: modelAdvice(runs), missing, rarelyTaken, constraints };
 }
 function outputShape(text) {
   const trimmed = text.trim();
@@ -27178,21 +27488,21 @@ function outputShape(text) {
   let fence = false;
   let prev = "";
   for (const raw of trimmed.split("\n")) {
-    const line = raw.trimEnd();
-    if (/^\s*```/.test(line)) {
-      shape.push(fence ? "code:end" : `code:${line.trim().slice(3).trim() || "text"}`);
+    const line2 = raw.trimEnd();
+    if (/^\s*```/.test(line2)) {
+      shape.push(fence ? "code:end" : `code:${line2.trim().slice(3).trim() || "text"}`);
       fence = !fence;
       prev = "";
       continue;
     }
     if (fence) continue;
     let kind = "";
-    const h2 = /^(#{1,6})\s+(.+)$/.exec(line);
+    const h2 = /^(#{1,6})\s+(.+)$/.exec(line2);
     if (h2) kind = `h${h2[1].length}:${h2[2].split(":")[0].replace(/[\d.,/-]+/g, "#").trim().toLowerCase()}`;
-    else if (/^\s*\|.*\|\s*$/.test(line)) kind = /^\s*\|[\s:|-]+\|\s*$/.test(line) ? "" : prev.startsWith("table") ? "table:row" : `table:${line.split("|").filter((c2) => c2.trim()).length}`;
-    else if (/^\s*[-*+]\s+/.test(line)) kind = "list";
-    else if (/^\s*\d+[.)]\s+/.test(line)) kind = "numbered";
-    else if (/^\s*\*\*[^*]+\*\*:?/.test(line)) kind = `label:${/\*\*([^*]+)\*\*/.exec(line)[1].toLowerCase()}`;
+    else if (/^\s*\|.*\|\s*$/.test(line2)) kind = /^\s*\|[\s:|-]+\|\s*$/.test(line2) ? "" : prev.startsWith("table") ? "table:row" : `table:${line2.split("|").filter((c2) => c2.trim()).length}`;
+    else if (/^\s*[-*+]\s+/.test(line2)) kind = "list";
+    else if (/^\s*\d+[.)]\s+/.test(line2)) kind = "numbered";
+    else if (/^\s*\*\*[^*]+\*\*:?/.test(line2)) kind = `label:${/\*\*([^*]+)\*\*/.exec(line2)[1].toLowerCase()}`;
     if (!kind || kind === prev && (kind === "list" || kind === "numbered" || kind === "table:row")) {
       if (kind) prev = kind;
       continue;
@@ -27203,6 +27513,136 @@ function outputShape(text) {
   return shape;
 }
 
+// ../../packages/analysis/src/handbook.ts
+var MAX_SOURCES = 5;
+var MIN_COMMAND_SESSIONS = 2;
+var WHEN_SHARE = 2 / 3;
+var WHEN_LIFT = 2;
+var SITUATIONS = [
+  { category: "dependency-manifest", when: "when changing dependencies", words: ["dependency", "package", "install", "lockfile", "upgrade"] },
+  { category: "migration", when: "when changing the database schema", words: ["migration", "schema", "database", "db", "sql"] },
+  { category: "ci-config", when: "when working on CI", words: ["ci", "pipeline", "workflow", "github", "action"] },
+  { category: "test", when: "when writing or changing tests", words: ["test", "spec"] },
+  { category: "config", when: "when changing configuration", words: ["config", "configuration", "setting"] },
+  { category: "docs", when: "when editing docs", words: ["doc", "readme", "documentation"] }
+];
+var VERIFY = [
+  { action: "run-tests", label: "Run tests with", words: ["test", "spec", "unit", "e2e"] },
+  { action: "run-build", label: "Build or typecheck with", words: ["build", "compile", "typecheck", "type", "tsc"] },
+  { action: "run-lint", label: "Lint with", words: ["lint", "format", "style", "prettier", "eslint"] }
+];
+var projectOf = (i) => i.primary.projectHash;
+var time4 = (t) => t.startedAt ? Date.parse(t.startedAt) || 0 : 0;
+function sourcesOf(group) {
+  const newest = [...group].sort((a, b3) => time4(b3.primary) - time4(a.primary));
+  return {
+    last: newest[0]?.primary.startedAt,
+    sources: newest.slice(0, MAX_SOURCES).map((i) => ({ date: i.primary.startedAt, tool: i.primary.source, request: i.primary.excerpt }))
+  };
+}
+function scopeOf(group) {
+  const hashes = new Set(group.map(projectOf));
+  if (hashes.size !== 1) return void 0;
+  const hash2 = [...hashes][0];
+  return hash2 ? { name: group[0].primary.projectName, hash: hash2 } : void 0;
+}
+function situation(group, others) {
+  const count3 = (xs, cat) => xs.filter((i) => i.primary.fileCategories.includes(cat)).length;
+  let best;
+  for (const s of SITUATIONS) {
+    const inside = count3(group, s.category) / group.length;
+    if (inside < WHEN_SHARE) continue;
+    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;
+}
+function rules(instances, forgotten) {
+  const out2 = [];
+  for (const r2 of recurringCorrectionsBySession(instances.map((i) => i.primary.corrections ?? []))) {
+    if (forgotten.has(r2.text) || !isSafeConstraint(r2)) continue;
+    const group = r2.instances.map((k3) => instances[k3]);
+    const project = scopeOf(group);
+    const members2 = new Set(group);
+    const others = instances.filter((i) => !members2.has(i) && (!project || projectOf(i) === project.hash));
+    const when = situation(group, others);
+    out2.push({ id: practiceId("rule", project?.hash, r2.text), kind: "rule", project, text: r2.text, when, sessions: r2.sessions, ...sourcesOf(group) });
+  }
+  return out2;
+}
+function commands(instances) {
+  const byProject2 = /* @__PURE__ */ new Map();
+  for (const i of instances) {
+    const h2 = projectOf(i);
+    if (h2) byProject2.set(h2, [...byProject2.get(h2) ?? [], i]);
+  }
+  const out2 = [];
+  for (const [hash2, group] of byProject2) {
+    for (const v2 of VERIFY) {
+      const worked = /* @__PURE__ */ new Map();
+      const failed = /* @__PURE__ */ new Map();
+      for (const i of group) {
+        const runs = i.primary.commands.filter((c2) => c2.action === v2.action);
+        for (const cmd2 of new Set(runs.map((c2) => c2.normalized).filter(isSafeExample))) {
+          const same = runs.filter((c2) => c2.normalized === cmd2);
+          if (same.some((c2) => !c2.failed)) worked.set(cmd2, [...worked.get(cmd2) ?? [], i]);
+          else failed.set(cmd2, (failed.get(cmd2) ?? 0) + 1);
+        }
+      }
+      const top = [...worked].sort((a, b3) => b3[1].length - a[1].length || a[0].localeCompare(b3[0]))[0];
+      if (!top || top[1].length < MIN_COMMAND_SESSIONS) continue;
+      const [cmd, sessions2] = top;
+      const notThis = [...failed].filter(([other, n]) => other !== cmd && n >= MIN_COMMAND_SESSIONS && !worked.has(other)).sort((a, b3) => b3[1] - a[1])[0];
+      const text = `${v2.label} \`${cmd}\`.${notThis ? ` Not \`${notThis[0]}\`: it failed in ${notThis[1]} sessions.` : ""}`;
+      out2.push({
+        id: practiceId("command", hash2, `${v2.action}:${cmd}`),
+        kind: "command",
+        project: { name: sessions2[0].primary.projectName, hash: hash2 },
+        text,
+        sessions: sessions2.length,
+        ...sourcesOf(sessions2)
+      });
+    }
+  }
+  return out2;
+}
+function practiceId(kind, project, key3) {
+  return shortHash(`${kind}|${project ?? "*"}|${key3}`, 8);
+}
+function buildHandbook(traces, opts = {}) {
+  const { instances } = deduplicate(traces);
+  return [...commands(instances), ...rules(instances, opts.forgotten ?? /* @__PURE__ */ new Set())].sort(
+    (a, b3) => b3.sessions - a.sessions || a.kind.localeCompare(b3.kind) || a.text.localeCompare(b3.text)
+  );
+}
+function practicesFor(practices, projectHash) {
+  return practices.filter((p3) => !p3.project || p3.project.hash === projectHash).sort((a, b3) => Number(!a.project) - Number(!b3.project));
+}
+var QUESTION_FILLER = new Set(
+  "a an the to it is are be do does did how what when where which who why we i you our my your here there this that in on of for with and or should can could would will".split(" ")
+);
+function terms(text) {
+  return new Set(
+    text.toLowerCase().split(/[^a-z0-9.-]+/).map((w2) => w2.replace(/^[.-]+|[.-]+$/g, "")).filter((w2) => w2.length > 1 && !QUESTION_FILLER.has(w2)).map(stem)
+  );
+}
+function practiceTerms(p3) {
+  const extra = [];
+  for (const s of SITUATIONS) if (p3.when === s.when) extra.push(...s.words);
+  for (const v2 of VERIFY) if (p3.text.startsWith(v2.label)) extra.push(...v2.words, "command", "run");
+  return terms(`${p3.text} ${p3.when ?? ""} ${extra.join(" ")}`);
+}
+function askHandbook(practices, question, projectHash, limit = 3) {
+  const q2 = terms(question);
+  if (!q2.size) return [];
+  return practices.map((p3) => {
+    const t = practiceTerms(p3);
+    const hits = [...q2].filter((w2) => t.has(w2)).length;
+    const local = p3.project ? p3.project.hash === projectHash ? 1.5 : 0.5 : 1;
+    return { practice: p3, score: hits / q2.size * local };
+  }).filter((a) => a.score > 0).sort((a, b3) => b3.score - a.score || b3.practice.sessions - a.practice.sessions).slice(0, limit);
+}
+
 // src/commands/scan.ts
 import { totalmem as totalmem2 } from "node:os";
 
@@ -27304,8 +27744,8 @@ function parseFrontmatter(content) {
   const end = content.indexOf("\n---", 3);
   if (end < 0) return void 0;
   const out2 = {};
-  for (const line of content.slice(4, end).split("\n")) {
-    const m2 = /^([a-z][a-z0-9-]*):\s*(.*)$/i.exec(line);
+  for (const line2 of content.slice(4, end).split("\n")) {
+    const m2 = /^([a-z][a-z0-9-]*):\s*(.*)$/i.exec(line2);
     if (!m2) continue;
     let v2 = m2[2].trim();
     if (v2.startsWith('"')) {
@@ -27331,15 +27771,15 @@ function checkSkill(content, expectedName) {
   const description = fm?.description ?? "";
   if (!description) errors.push("frontmatter `description` is missing");
   if (description.length > 1024) errors.push("description is longer than 1024 characters");
-  for (const section of REQUIRED_SECTIONS) if (!content.includes(`
-${section}
-`)) errors.push(`missing section "${section}"`);
-  const steps = (content.split("## Workflow")[1]?.split("\n## ")[0] ?? "").split("\n").filter((l2) => /^\d+\. /.test(l2)).length;
-  if (steps < 3) errors.push(`workflow has ${steps} steps; at least 3 expected`);
+  for (const section2 of REQUIRED_SECTIONS) if (!content.includes(`
+${section2}
+`)) errors.push(`missing section "${section2}"`);
+  const steps2 = (content.split("## Workflow")[1]?.split("\n## ")[0] ?? "").split("\n").filter((l2) => /^\d+\. /.test(l2)).length;
+  if (steps2 < 3) errors.push(`workflow has ${steps2} steps; at least 3 expected`);
   if (findLeaks(content).length) errors.push("contains sensitive-looking content (secret, email, or home path)");
   if (/(^|[\s`'"(])(\/Users\/|\/home\/|[A-Z]:\\Users\\)/m.test(content)) errors.push("contains a local absolute path");
   if (!/generator: reflex/.test(content)) warnings.push("no Reflex provenance metadata (hand-written or edited skill)");
-  return { ok: errors.length === 0, errors, warnings, name, steps, lines };
+  return { ok: errors.length === 0, errors, warnings, name, steps: steps2, lines };
 }
 
 // ../../packages/skills/src/diff.ts
@@ -27579,8 +28019,9 @@ function runClaudeInSandbox(sandbox, skillName2, timeoutMs = 6 * 60 * 1e3) {
     "--allowedTools",
     ...ALLOWED_TOOLS
   ];
+  const launch = agentLaunch("claude", args);
   return new Promise((resolve5) => {
-    const child = spawn("claude", args, { cwd: sandbox.dir, stdio: ["ignore", "pipe", "ignore"] });
+    const child = spawn(launch.command, launch.args, { cwd: sandbox.dir, stdio: ["ignore", "pipe", "ignore"], windowsVerbatimArguments: launch.windowsVerbatimArguments });
     let buffer = "";
     let timedOut = false;
     const run2 = { exitCode: null, skillUsed: false, commands: [], editedFiles: [], testsPass: false, timedOut: false };
@@ -27593,19 +28034,19 @@ function runClaudeInSandbox(sandbox, skillName2, timeoutMs = 6 * 60 * 1e3) {
       const base = bases.find((b3) => p3.startsWith(b3));
       return base ? p3.slice(base.length) : displayPath(p3);
     };
-    const handle = (line) => {
+    const handle = (line2) => {
       let msg;
       try {
-        msg = JSON.parse(line);
+        msg = JSON.parse(line2);
       } catch {
         return;
       }
-      if (msg.type === "result" && typeof msg.result === "string") run2.finalMessage = redact(msg.result.slice(0, 2e3));
+      if (msg.type === "result" && typeof msg.result === "string") run2.finalMessage = redactTruncated(msg.result, 2e3);
       if (msg.type !== "assistant" || !Array.isArray(msg.message?.content)) return;
       for (const block of msg.message.content) {
         if (block.type !== "tool_use") continue;
         if (block.name === "Skill" && String(block.input?.skill ?? "").replace(/^.*:/, "") === skillName2) run2.skillUsed = true;
-        if (block.name === "Bash" && typeof block.input?.command === "string") run2.commands.push(redact(block.input.command.slice(0, 200)));
+        if (block.name === "Bash" && typeof block.input?.command === "string") run2.commands.push(redactTruncated(block.input.command, 200));
         if ((block.name === "Edit" || block.name === "Write") && typeof block.input?.file_path === "string")
           run2.editedFiles.push(sandboxRelative(block.input.file_path));
       }
@@ -27687,15 +28128,16 @@ function cleanMemoryText(text) {
   if (!t || redactions > 0 || findLeaks(t).length) return void 0;
   return t;
 }
-function renderMemoryBlock(rules) {
+function renderMemoryBlock(rules2) {
   const lines = [
     MEMORY_START,
     "## Remembered by Reflex",
     "",
     "Corrections the developer gave coding agents in more than one past session. Follow them unless the current task says otherwise.",
     "Managed by `reflex memory`: edits inside this block are replaced on the next scan.",
+    'To see how work is done in the current repository (commands that work, rules the developer gave), run `reflex handbook --json`, or `reflex handbook ask "<question>" --json`. Both are read-only.',
     "",
-    ...rules.map((r2) => `- ${r2.text}${r2.sessions ? ` (${r2.sessions} sessions)` : ""}`),
+    ...rules2.map((r2) => `- ${r2.text}${r2.sessions ? ` (${r2.sessions} sessions)` : ""}`),
     MEMORY_END
   ];
   return lines.join("\n");
@@ -27774,19 +28216,19 @@ function learnedSection(review, opts = {}) {
     for (const c2 of constraints) lines.push(`- ${c2.text} (${c2.sessions} sessions)`);
   }
   lines.push(LEARNED_END);
-  const section = redact(lines.join("\n"));
-  if (findLeaks(section).length) throw new Error("The proposed section still contains sensitive-looking content; refusing to propose it.");
-  return section;
+  const section2 = redact(lines.join("\n"));
+  if (findLeaks(section2).length) throw new Error("The proposed section still contains sensitive-looking content; refusing to propose it.");
+  return section2;
 }
-function applyLearned(content, section) {
+function applyLearned(content, section2) {
   const starts = content.split(LEARNED_START).length - 1;
   const ends = content.split(LEARNED_END).length - 1;
   if (starts > 1 || ends > 1 || starts !== ends || starts && content.indexOf(LEARNED_END) < content.indexOf(LEARNED_START))
     throw new Error(`The skill's "Learned from your sessions" markers are incomplete or repeated. Fix or remove ${LEARNED_START} and ${LEARNED_END}, then run reflex improve again.`);
   const start = content.indexOf(LEARNED_START);
   const end = start >= 0 ? content.indexOf(LEARNED_END, start) : -1;
-  if (start >= 0 && end >= 0) return content.slice(0, start) + section + content.slice(end + LEARNED_END.length);
-  return content.replace(/\n*$/, "\n\n") + section + "\n";
+  if (start >= 0 && end >= 0) return content.slice(0, start) + section2 + content.slice(end + LEARNED_END.length);
+  return content.replace(/\n*$/, "\n\n") + section2 + "\n";
 }
 function withoutLearned(content) {
   const start = content.indexOf(LEARNED_START);
@@ -27809,6 +28251,7 @@ async function applyToOwnSkill(path, readHash, next, backupDir, name, now = /* @
   if (sha256(current) !== readHash) throw new Error("The skill changed since Reflex read it; run `reflex improve` again.");
   const stat4 = await lstat6(path);
   if (!stat4.isFile()) throw new Error("Not a regular file.");
+  if ((stat4.mode & 146) === 0) throw new Error("You can't write to this skill file, so Reflex won't change it.");
   await access(path, constants3.W_OK).catch(() => {
     throw new Error("You can't write to this skill file, so Reflex won't change it.");
   });
@@ -27876,19 +28319,20 @@ function runClaudeBench(dir, task, model2, tools, timeoutMs) {
     "--allowedTools",
     ...tools
   ];
+  const launch = agentLaunch("claude", args);
   const started = Date.now();
   return new Promise((resolve5) => {
-    const child = spawn2("claude", args, { cwd: dir, stdio: ["ignore", "pipe", "ignore"] });
+    const child = spawn2(launch.command, launch.args, { cwd: dir, stdio: ["ignore", "pipe", "ignore"], windowsVerbatimArguments: launch.windowsVerbatimArguments });
     const run2 = { exitCode: null, timedOut: false, durationMs: 0 };
     let buffer = "";
     const timer = setTimeout(() => {
       run2.timedOut = true;
       child.kill("SIGTERM");
     }, timeoutMs);
-    const handle = (line) => {
+    const handle = (line2) => {
       let msg;
       try {
-        msg = JSON.parse(line);
+        msg = JSON.parse(line2);
       } catch {
         return;
       }
@@ -27940,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
@@ -28067,6 +28514,7 @@ function parseJson(raw, shape, what) {
   if (!result.success) throw new Error(`Reflex database has a malformed ${what}. Run \`reflex scan\` again.`);
   return result.data;
 }
+var BUSY_TIMEOUT_MS = 1e4;
 var Store = class {
   db;
   constructor(file2 = paths.db()) {
@@ -28075,6 +28523,8 @@ var Store = class {
     mkdirSync(dir, { recursive: true, mode: 448 });
     this.db = new DatabaseSync2(file2);
     chmodSync(file2, 384);
+    this.db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+    this.db.exec("PRAGMA journal_mode = WAL");
     const version2 = Number(this.db.prepare("PRAGMA user_version").get().user_version);
     if (version2 < 4) this.db.exec("DROP TABLE IF EXISTS sessions");
     this.db.exec(SCHEMA);
@@ -28089,7 +28539,7 @@ var Store = class {
   }
   /** Record a scan and make the given cached traces its working set (what suggest, stats and the TUI see). */
   saveScan(scan2, traceRows) {
-    this.db.exec("BEGIN");
+    this.db.exec("BEGIN IMMEDIATE");
     try {
       const res = this.db.prepare(
         "INSERT INTO scans (started_at, days, mode, sources_json, files, sessions, partial, unreadable, skipped_records) VALUES (?,?,?,?,?,?,?,?,?)"
@@ -28129,7 +28579,7 @@ var Store = class {
   }
   /** Replace what is cached for one file (its identity and its traces) atomically. */
   saveFile(file2, traces) {
-    this.db.exec("BEGIN");
+    this.db.exec("BEGIN IMMEDIATE");
     try {
       this.db.prepare("DELETE FROM traces WHERE path = ?").run(file2.path);
       this.db.prepare(
@@ -28160,7 +28610,7 @@ var Store = class {
   }
   /** Rewrite a kept trace in place (re-redaction after the rules or the user's identity changed). */
   updateKeptTraces(path, traces, keys) {
-    this.db.exec("BEGIN");
+    this.db.exec("BEGIN IMMEDIATE");
     try {
       const update = this.db.prepare("UPDATE traces SET trace_json = ? WHERE row_id = ?");
       for (const t of traces) update.run(JSON.stringify(t.trace), t.row);
@@ -28205,7 +28655,7 @@ var Store = class {
   /** Store the current suggestions, keeping any earlier approve/reject decision for the same slug. */
   saveSuggestions(scanId, suggestions) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.db.exec("BEGIN");
+    this.db.exec("BEGIN IMMEDIATE");
     try {
       this.db.prepare("UPDATE suggestions SET rank = NULL").run();
       const upsert = this.db.prepare(
@@ -28299,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");
+    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");
@@ -28315,11 +28765,11 @@ var Store = class {
     this.db.prepare("DELETE FROM embeddings WHERE key NOT IN (SELECT value FROM json_each(?))").run(JSON.stringify(keep));
   }
   /** Replace the mined memory with the latest result. User decisions (forgotten, added) are kept. */
-  syncMinedMemory(rules) {
+  syncMinedMemory(rules2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.db.exec("BEGIN");
+    this.db.exec("BEGIN IMMEDIATE");
     try {
-      const keep = new Set(rules.map((r2) => r2.text));
+      const keep = new Set(rules2.map((r2) => r2.text));
       for (const row of this.db.prepare("SELECT text FROM memory_entries WHERE origin = 'mined' AND status = 'active'").all()) {
         if (!keep.has(row.text)) this.db.prepare("DELETE FROM memory_entries WHERE text = ?").run(row.text);
       }
@@ -28327,7 +28777,7 @@ var Store = class {
         `INSERT INTO memory_entries (text, origin, status, sessions, updated_at) VALUES (?, 'mined', 'active', ?, ?)
          ON CONFLICT(text) DO UPDATE SET sessions = excluded.sessions, updated_at = excluded.updated_at`
       );
-      for (const r2 of rules) upsert.run(r2.text, r2.sessions, now);
+      for (const r2 of rules2) upsert.run(r2.text, r2.sessions, now);
       this.db.exec("COMMIT");
     } catch (err) {
       this.db.exec("ROLLBACK");
@@ -28684,8 +29134,8 @@ var COMFORTABLE = { memoryGB: 8, cores: 4 };
 function machineIsSmall(totalBytes = totalmem(), cores = availableParallelism()) {
   return totalBytes / 1e9 < COMFORTABLE.memoryGB - 0.5 || cores < COMFORTABLE.cores;
 }
-function embeddingSeconds(model2, sessions2, threads = embeddingThreads()) {
-  const speedup = 1 + (threads - 1) * 0.83;
+function embeddingSeconds(model2, sessions2, threads2 = embeddingThreads()) {
+  const speedup = 1 + (threads2 - 1) * 0.83;
   return sessions2 * model2.secondsPerSession / speedup;
 }
 
@@ -28705,8 +29155,8 @@ async function tokenizerFor(dir, model2) {
     return (text) => tokenizer2.encode(text, model2.maxTokens);
   }
   const { Tokenizer } = await import("./tokenizers-CLBWC4RJ.js");
-  const [json2, config2] = await Promise.all([readVerified(dir, "tokenizer.json", model2), readVerified(dir, "tokenizer_config.json", model2)]);
-  const tokenizer = new Tokenizer(JSON.parse(json2.toString("utf8")), JSON.parse(config2.toString("utf8")));
+  const [json3, config2] = await Promise.all([readVerified(dir, "tokenizer.json", model2), readVerified(dir, "tokenizer_config.json", model2)]);
+  const tokenizer = new Tokenizer(JSON.parse(json3.toString("utf8")), JSON.parse(config2.toString("utf8")));
   return (text) => {
     const ids = tokenizer.encode(text).ids;
     return ids.length > model2.maxTokens ? [...ids.slice(0, model2.maxTokens - 1), ids[ids.length - 1]] : ids;
@@ -30430,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 {
@@ -30502,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);
@@ -30939,7 +31389,8 @@ async function validate2(name, opts) {
     out(c.dim(`  Or let Reflex run it: reflex validate ${name} --run`));
     return;
   }
-  if (spawnSync3("claude", ["--version"], { stdio: "ignore" }).status !== 0) {
+  const claude = agentLaunch("claude", ["--version"]);
+  if (spawnSync3(claude.command, claude.args, { stdio: "ignore", windowsVerbatimArguments: claude.windowsVerbatimArguments }).status !== 0) {
     fail("The `claude` CLI was not found on PATH.");
     return;
   }
@@ -30960,7 +31411,7 @@ async function validate2(name, opts) {
   if (run2.finalMessage) {
     out();
     out(c.dim("  Final message:"));
-    for (const line of run2.finalMessage.split("\n").slice(0, 14)) out(c.dim(`    ${line}`));
+    for (const line2 of run2.finalMessage.split("\n").slice(0, 14)) out(c.dim(`    ${line2}`));
   }
   out();
   if (run2.skillUsed && run2.testsPass) ok(`${name} worked on a new task.`);
@@ -30971,9 +31422,9 @@ async function validate2(name, opts) {
 var sourceSummary = (s) => Object.entries(s.sources).map(([k3, n]) => `${SOURCE_LABELS[k3] ?? k3} ${n}`).join(", ");
 function costLine(s) {
   const cost = s.cost;
-  const line = describeCost(cost);
-  if (cost.runsWithTokens) return line;
-  return s.sources.cursor ? `${line} ${c.dim("(Cursor doesn't record tokens)")}` : line;
+  const line2 = describeCost(cost);
+  if (cost.runsWithTokens) return line2;
+  return s.sources.cursor ? `${line2} ${c.dim("(Cursor doesn't record tokens)")}` : line2;
 }
 function renderSuggestion(entry) {
   const s = entry.data;
@@ -31187,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;
   }
@@ -31228,10 +31833,15 @@ async function doctor() {
   out();
   out("Agent CLIs (for fresh-task validation)");
   for (const bin of ["claude", "codex"]) {
-    const found = spawnSync4(bin, ["--version"], { stdio: "ignore" }).status === 0;
+    const launch = agentLaunch(bin, ["--version"]);
+    const found = spawnSync4(launch.command, launch.args, { stdio: "ignore", windowsVerbatimArguments: launch.windowsVerbatimArguments }).status === 0;
     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();
@@ -31323,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", "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.");
 }
@@ -31341,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;
 }
@@ -31352,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(
@@ -31360,15 +31976,15 @@ 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) => {
-      const meta3 = e2.origin === "added" ? "added by you" : plural(e2.sessions, "session");
-      const line = `  ${String(i + 1).padStart(2)}. ${e2.text} ${c.dim(`(${meta3})`)}`;
-      out(e2.status === "forgotten" ? c.dim(`${line} forgotten`) : line);
+    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);
     });
     out();
     out(c.dim('reflex memory forget <n> \xB7 remember <n> \xB7 add "<text>" \xB7 on \xB7 off'));
@@ -31461,12 +32077,12 @@ async function storedSessions() {
   }
 }
 async function machineCheck(model2) {
-  const threads = embeddingThreads();
+  const threads2 = embeddingThreads();
   const memGB = totalmem3() / 1e9;
   const sessions2 = await storedSessions();
-  const estimate = sessions2 ? `about ${duration3(embeddingSeconds(model2, sessions2, threads))} for your ${sessions2} stored sessions` : `about ${duration3(embeddingSeconds(model2, 100, threads))} per 100 sessions`;
+  const estimate = sessions2 ? `about ${duration3(embeddingSeconds(model2, sessions2, threads2))} for your ${sessions2} stored sessions` : `about ${duration3(embeddingSeconds(model2, 100, threads2))} per 100 sessions`;
   rows([
-    ["This machine", `${memGB.toFixed(0)} GB memory, ${availableParallelism2()} cores (${threads} used for embedding)`],
+    ["This machine", `${memGB.toFixed(0)} GB memory, ${availableParallelism2()} cores (${threads2} used for embedding)`],
     ["First scan", `${estimate}; later scans only embed new sessions (older CPUs can take up to 3x longer)`]
   ]);
   out();
@@ -31527,6 +32143,7 @@ async function modelFetch(opts) {
   const total = modelBytes(model2);
   let done = 0;
   let last = 0;
+  const closeNetwork = allowHosts(MODEL_HOSTS);
   try {
     await fetchModel(
       paths.models(),
@@ -31545,6 +32162,8 @@ async function modelFetch(opts) {
   } catch (err) {
     spin.stop("Download failed");
     throw err;
+  } finally {
+    closeNetwork();
   }
   await setActiveModel(paths.models(), model2);
   spin.stop("Downloaded and verified");
@@ -31575,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());
@@ -31595,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}+).`));
@@ -31646,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);
@@ -31658,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 {
@@ -31724,19 +32419,19 @@ async function improve(name, opts) {
     const behavior = opts.behavior === true;
     out();
     renderReview(review, behavior);
-    const section = learnedSection(review, { behavior });
-    if (!section) {
+    const section2 = learnedSection(review, { behavior });
+    if (!section2) {
       ok(
         behavior || !review.missing.length && !review.constraints.length ? `Nothing to add: ${name} already covers what these sessions did.` : `Nothing to add that keeps ${name} doing exactly what it does. --behavior proposes the steps and corrections above.`
       );
       return;
     }
-    const next = applyLearned(content, section);
-    const proposalDir = assertInside(paths.home(), join20(paths.home(), "proposals", name));
+    const next = applyLearned(content, section2);
+    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));
@@ -31782,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 {
@@ -31790,15 +32485,136 @@ async function improve(name, opts) {
   }
 }
 
+// src/commands/handbook.ts
+import { dirname as dirname8 } from "node:path";
+var TOOL = { "claude-code": "Claude Code", codex: "Codex", cursor: "Cursor" };
+function load() {
+  const store = new Store();
+  try {
+    if (!store.latestScan()) throw new Error("No scan yet. Run `reflex scan --days 30` first.");
+    const forgotten = new Set(store.memoryEntries().filter((e2) => e2.status === "forgotten").map((e2) => e2.text));
+    return buildHandbook(store.traces(), { forgotten });
+  } finally {
+    store.close();
+  }
+}
+function scope(practices, opts) {
+  const known = new Map(practices.filter((p3) => p3.project).map((p3) => [p3.project.hash, p3.project]));
+  if (opts.project) {
+    const hit = [...known.values()].find((p3) => p3.name === opts.project || p3.hash === opts.project);
+    if (!hit) throw new Error(`No practices for a repository named "${opts.project}". \`reflex handbook --all\` lists them.`);
+    return hit;
+  }
+  for (let dir = process.cwd(); ; dir = dirname8(dir)) {
+    const hit = known.get(shortHash(dir));
+    if (hit) return hit;
+    if (dirname8(dir) === dir) return {};
+  }
+}
+function meta3(p3) {
+  return `${plural(p3.sessions, "session")}${p3.last ? ` \xB7 last ${shortDate(p3.last)}` : ""} \xB7 ${p3.id}`;
+}
+function line(p3) {
+  return `    ${p3.text}${p3.when ? c.cyan(` (${p3.when})`) : ""}  ${c.dim(meta3(p3))}`;
+}
+function section(name, items) {
+  if (!items.length) return;
+  out(c.bold(`  ${name}`));
+  for (const p3 of items) out(line(p3));
+  out();
+}
+var json2 = (value) => out(JSON.stringify(value, null, 2));
+async function handbook(opts) {
+  const all = load();
+  if (opts.all) {
+    if (opts.json) return json2({ project: null, practices: all });
+    title(`Handbook \xB7 every repository \xB7 ${plural(all.length, "practice")}`);
+    const groups = /* @__PURE__ */ new Map();
+    for (const p3 of all) groups.set(p3.project?.name ?? "Across repositories", [...groups.get(p3.project?.name ?? "Across repositories") ?? [], p3]);
+    for (const [name, items] of groups) section(name, items);
+    return;
+  }
+  const where = scope(all, opts);
+  const practices = practicesFor(all, where.hash);
+  if (opts.json) return json2({ project: where.hash ? where : null, practices });
+  title(`Handbook \xB7 ${where.name ?? "no repository matched this folder"}`);
+  if (!practices.length) {
+    out("Nothing learned yet. Practices come from commands that worked and corrections you repeated, in at least 2 independent sessions.");
+    return;
+  }
+  const own2 = practices.filter((p3) => p3.project);
+  section("Commands that work here", own2.filter((p3) => p3.kind === "command"));
+  section("Rules you gave agents here", own2.filter((p3) => p3.kind === "rule"));
+  section("Rules across your repositories", practices.filter((p3) => !p3.project));
+  out(c.dim(`reflex handbook show <id> \xB7 ask "<question>" \xB7 export \xB7 --json${where.hash ? "" : " \xB7 --project <name> \xB7 --all"}`));
+}
+async function handbookShow(id, opts) {
+  const p3 = load().find((x2) => x2.id === id);
+  if (!p3) throw new Error(`No practice ${id}. \`reflex handbook\` lists them with their ids.`);
+  if (opts.json) return json2(p3);
+  title(p3.text);
+  if (p3.when) out(`  Applies ${p3.when}.`);
+  out(`  ${p3.project?.name ? `In ${p3.project.name}` : "Across your repositories"} \xB7 ${plural(p3.sessions, "independent session")}`);
+  out();
+  out(c.bold(`  Sessions behind it${p3.sessions > p3.sources.length ? ` (newest ${p3.sources.length})` : ""}`));
+  for (const s of p3.sources) out(`  ${shortDate(s.date)}  ${(TOOL[s.tool] ?? s.tool).padEnd(11)}  ${c.dim(s.request || "(no request text)")}`);
+}
+async function handbookAsk(words2, opts) {
+  const question = words2.join(" ").trim();
+  if (!question) throw new Error('Ask a question: reflex handbook ask "how do we run tests here?"');
+  const all = load();
+  const where = scope(all, opts);
+  const answers = askHandbook(practicesFor(all, where.hash), question, where.hash);
+  if (opts.json) return json2({ question, project: where.hash ? where : null, answers: answers.map((a) => ({ score: Number(a.score.toFixed(3)), ...a.practice })) });
+  out();
+  if (!answers.length) {
+    out(`Nothing in the handbook${where.name ? ` for ${where.name}` : ""} answers that. Reflex only knows what past sessions showed.`);
+    return;
+  }
+  for (const { practice: p3 } of answers) {
+    out(`${c.green("\u203A")} ${p3.text}${p3.when ? c.cyan(` (${p3.when})`) : ""}`);
+    out(c.dim(`  ${p3.project?.name ? `in ${p3.project.name}` : "across your repositories"} \xB7 ${meta3(p3)} \xB7 reflex handbook show ${p3.id}`));
+  }
+}
+async function handbookExport(opts) {
+  const all = load();
+  const where = opts.all ? {} : scope(all, opts);
+  const practices = opts.all ? all : practicesFor(all, where.hash);
+  const name = opts.all ? "all repositories" : where.name ?? "this folder";
+  const entry = (p3) => `- ${p3.text}${p3.when ? ` *(${p3.when})*` : ""} \xB7 ${plural(p3.sessions, "session")}${p3.last ? `, last ${shortDate(p3.last)}` : ""}`;
+  const lines = [
+    `# Handbook: ${name}`,
+    "",
+    `Learned by Reflex from past coding-agent sessions, ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}. Each item held in at least 2 independent sessions; the count says how many.`,
+    ""
+  ];
+  const groups = [
+    ["Commands that work", practices.filter((p3) => p3.kind === "command")],
+    ["Rules", practices.filter((p3) => p3.kind === "rule" && p3.project)],
+    ["Rules across repositories", practices.filter((p3) => p3.kind === "rule" && !p3.project)]
+  ];
+  for (const [heading, items] of groups) {
+    if (!items.length) continue;
+    lines.push(`## ${heading}`, "");
+    if (opts.all && heading !== "Rules across repositories") {
+      const byRepo = /* @__PURE__ */ new Map();
+      for (const p3 of items) byRepo.set(p3.project?.name ?? "unnamed", [...byRepo.get(p3.project?.name ?? "unnamed") ?? [], p3]);
+      for (const [repo, ps] of byRepo) lines.push(`### ${repo}`, "", ...ps.map(entry), "");
+    } else lines.push(...items.map(entry), "");
+  }
+  if (!practices.length) lines.push("Nothing learned yet.", "");
+  out(lines.join("\n").trimEnd());
+}
+
 // src/commands/route.ts
 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`;
@@ -31903,7 +32719,8 @@ async function runRouted(words2, opts) {
   if (!run2) return;
   const model2 = run2.model ? ["--model", run2.model] : [];
   const args = run2.source === "claude-code" ? [...model2, "--session-id", run2.nativeId, request] : [...model2, request];
-  const res = spawnSync5(CLI[run2.source], args, { stdio: "inherit" });
+  const launch = agentLaunch(CLI[run2.source], args);
+  const res = spawnSync5(launch.command, launch.args, { stdio: "inherit", windowsVerbatimArguments: launch.windowsVerbatimArguments });
   if (res.error) throw new Error(`Could not start ${CLI[run2.source]}: ${res.error.message}`);
   process.exitCode = res.status ?? 0;
   if (opts.ask !== false && interactive()) await askOutcome(runId);
@@ -32017,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) }));
@@ -32051,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.`);
@@ -32064,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 {
@@ -32207,8 +33024,8 @@ function hcat(blocks, gap) {
   for (let i = 0; i < h2; i++) {
     let l2 = [];
     blocks.forEach((b3, j2) => {
-      const line = b3.lines[i];
-      l2 = l2.concat(line ? fit(line, b3.w) : [S2(" ".repeat(b3.w))]);
+      const line2 = b3.lines[i];
+      l2 = l2.concat(line2 ? fit(line2, b3.w) : [S2(" ".repeat(b3.w))]);
       if (j2 < blocks.length - 1) l2.push(S2(" ".repeat(gap)));
     });
     out2.push(l2);
@@ -32381,18 +33198,18 @@ function hbars(title2, items, w2, o2 = {}) {
 function mdLines(src, w2) {
   const out2 = [];
   let fm = 0;
-  src.forEach((line) => {
+  src.forEach((line2) => {
     let c2 = "fg";
     let b3 = null;
-    if (line === "---") {
+    if (line2 === "---") {
       fm++;
       c2 = "dim";
     } else if (fm === 1) c2 = "dim";
-    else if (line.startsWith("#")) {
+    else if (line2.startsWith("#")) {
       c2 = "hi";
       b3 = BOLD;
     }
-    wrap(line, w2).forEach((t) => out2.push([S2(t, c2, b3)]));
+    wrap(line2, w2).forEach((t) => out2.push([S2(t, c2, b3)]));
   });
   return out2;
 }
@@ -32702,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);
@@ -34145,7 +34962,12 @@ function runTui(opts) {
     const resume = async (c2) => {
       let error62;
       await term.suspend(() => {
-        error62 = spawnSync6(c2.cmd, c2.args, { stdio: "inherit", cwd: c2.cwd }).error;
+        try {
+          const launch = agentLaunch(c2.cmd, c2.args);
+          error62 = spawnSync6(launch.command, launch.args, { stdio: "inherit", cwd: c2.cwd, windowsVerbatimArguments: launch.windowsVerbatimArguments }).error;
+        } catch (e2) {
+          error62 = e2 instanceof Error ? e2 : new Error(String(e2));
+        }
       });
       term.invalidate();
       await reload();
@@ -34235,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);
@@ -34264,11 +35086,11 @@ 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 isFile2(path) {
+async function isFile3(path) {
   try {
     return (await lstat9(path)).isFile();
   } catch {
@@ -34292,7 +35114,7 @@ async function skillItems(store, scan2, targets, now) {
   const names = new Set(generated.map((k3) => k3.name));
   const installs = store.installations();
   const installed = async (name) => {
-    for (const r2 of installs) if (r2.skill === name && await isFile2(r2.path)) return true;
+    for (const r2 of installs) if (r2.skill === name && await isFile3(r2.path)) return true;
     return false;
   };
   const path = (name) => claude ? toCells(`${displayPath(claude.skillsDir)}/${name}/SKILL.md`) : "";
@@ -34315,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`)) };
@@ -34516,29 +35338,29 @@ 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 statSync2 } from "node:fs";
-import { basename as basename8, delimiter as delimiter3, 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) {
   const sessions2 = /* @__PURE__ */ new Map();
   const bySession = /* @__PURE__ */ new Map();
-  const meta3 = /* @__PURE__ */ new Map();
+  const meta4 = /* @__PURE__ */ new Map();
   const all = [];
   for (const { t, at, tool, cost } of priced) {
     const nativeId = t.sessionId.slice(t.source.length + 1);
     const key3 = sessions2.has(nativeId.slice(0, 8)) ? nativeId : nativeId.slice(0, 8);
     sessions2.set(key3, { source: t.source, nativeId });
-    meta3.set(key3, { usd: cost?.usd, turnCount: t.requests });
+    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 = {
@@ -34548,7 +35370,7 @@ function buildSearch(priced) {
       return all.filter((e2) => (tool === "all" || e2.tool === tool) && (!needle || e2.lower.includes(needle)));
     },
     session(id) {
-      return { turns: bySession.get(id) ?? [], ...meta3.get(id) };
+      return { turns: bySession.get(id) ?? [], ...meta4.get(id) };
     }
   };
   return { index, sessions: sessions2 };
@@ -34562,24 +35384,24 @@ 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 line of buf.subarray(0, n).toString("utf8").split("\n")) {
+    for (const line2 of buf.subarray(0, n).toString("utf8").split("\n")) {
       try {
-        const cwd = JSON.parse(line).cwd;
-        if (typeof cwd === "string" && statSync2(cwd).isDirectory()) return cwd;
+        const cwd = JSON.parse(line2).cwd;
+        if (typeof cwd === "string" && statSync3(cwd).isDirectory()) return cwd;
       } catch {
         continue;
       }
@@ -34596,10 +35418,9 @@ 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;
 }
-var onPath3 = (cmd) => (process.env.PATH ?? "").split(delimiter3).some((d3) => d3 && existsSync7(join23(d3, cmd)));
 function resumeCommand(ref) {
   if (!ref || !SESSION_ID.test(ref.nativeId)) return { ok: false, message: "this session cannot be resumed", tone: "dim" };
   const id = ref.nativeId;
@@ -34612,14 +35433,14 @@ function resumeCommand(ref) {
   const dir = cursorWorkspace(id);
   if (!dir) return { ok: false, message: "this Cursor chat has no workspace folder on this machine", tone: "dim" };
   const done = `opened ${toCells(basename8(dir))} in Cursor \xB7 the chat is in its agent history`;
-  if (onPath3("cursor")) return { cmd: "cursor", args: [dir], done };
+  if (findOnPath("cursor")) return { cmd: "cursor", args: [dir], done };
   if (process.platform === "darwin") return { cmd: "open", args: ["-a", "Cursor", dir], done };
   return { ok: false, message: `open ${toCells(dir)} in Cursor; the chat is in its agent history`, tone: "dim" };
 }
 
 // ../../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, ""];
@@ -34627,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", "");
@@ -34649,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) {
@@ -34801,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;
@@ -34861,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
@@ -34906,8 +35727,7 @@ async function tui() {
 
 // src/main.ts
 quietSqliteWarning();
-var fetchingModel = process.argv[2] === "model" && process.argv[3] === "fetch";
-if (!fetchingModel) installNetworkGuard();
+installNetworkGuard();
 process.stdout.on("error", (err) => {
   if (err.code === "EPIPE") process.exit(0);
   throw err;
@@ -34925,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.0").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();
@@ -34940,6 +35760,10 @@ program2.command("scan").description("read recent coding-agent history (asks fir
 );
 program2.command("sessions").description("list sessions from the last scan (redacted)").action(run(sessions));
 program2.command("agents").description("sessions that launched agents (Cursor), what kinds, and how much work the agents did").action(run(agents));
+var handbookCmd = program2.command("handbook").description("how work is done in this repository, learned from past sessions (read-only, safe for agents)").option("--project <name>", "a repository by name instead of the current folder").option("--all", "every repository").option("--json", "machine-readable output").action(run(async (o2) => handbook(o2)));
+handbookCmd.command("show <id>").description("one practice and the sessions behind it").option("--json", "machine-readable output").action(run(async (id, _o, cmd) => handbookShow(id, cmd.optsWithGlobals())));
+handbookCmd.command("ask <question...>").description("practices that answer a question, with their sources").option("--project <name>", "a repository by name instead of the current folder").option("--json", "machine-readable output").action(run(async (q2, _o, cmd) => handbookAsk(q2, cmd.optsWithGlobals())));
+handbookCmd.command("export").description("a Markdown handbook for a teammate or new hire (no request text)").option("--project <name>", "a repository by name instead of the current folder").option("--all", "every repository").action(run(async (_o, cmd) => handbookExport(cmd.optsWithGlobals())));
 program2.command("suggest").description("detect repeated workflows and review them").option("--all", "include rejected suggestions").option("--no-interactive", "print suggestions without the review prompt").action(run(suggest));
 program2.command("show <suggestion>").description("show a suggestion in detail (number or name)").action(run(show));
 program2.command("evidence <suggestion>").description("show the sessions behind a suggestion").action(run(evidence));
@@ -34971,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);