@aaa-sentinel/ai-usage 0.1.2 → 0.2.1

package/README.md

@@ -39,7 +39,12 @@ path of a transcript. The CLI reads only the tool its connection is for: a conne
 Cursor never opens a Claude Code transcript, and `gh` is not called unless the connection is
 Copilot.
 
-The figures are not converted to money and are not added to billed or estimated spend.
+For quota headroom, a Claude Code connection also sends the day's peak share of the 5-hour and
+weekly limits and the end time of any 5-hour window that reached 100 %; a Copilot connection sends
+the month's total of AI credits, without amounts.
+
+The CLI sends no money figures. AAA Sentinel shows what the usage would cost at API list prices,
+always apart from billed or estimated spend and never added to them.
 
 ## Setup, step by step
 
@@ -215,17 +220,25 @@ systemd=true
   a dev container or a remote machine over SSH, install the agent there. A cost figure that
   sometimes comes with the session is not uploaded. A turn here is one call to the model, so a
   reply that uses tools counts several.
+  Claude Code passes its 5-hour and weekly limits only to the status line, so the first `report`
+  sets `sentinel-usage statusline` as the status line in Claude Code's `settings.json`. If you
+  already had one, it keeps running and is what you see; if not, you see the 5-hour and weekly
+  usage. Remove or change it and the agent does not put it back; `logout` restores yours.
 - **GitHub Copilot.** Needs the [GitHub CLI](https://cli.github.com) signed in to the account that
   holds the Copilot plan: `gh auth login`, then `gh auth status` must show that account
   (`winget install GitHub.cli` on Windows, `brew install gh` on macOS). Premium requests by model
   are read through `gh`; GitHub does not report tokens. This is account usage, not device usage, so
-  two laptops do not double it. If `gh` answers 401 or 403, an empty row is not written.
+  two laptops do not double it. If `gh` answers 401 or 403, an empty row is not written. The
+  month's AI credits are read the same way and only their total is sent, to compare with the
+  credits the plan includes.
 - **Codex.** Session counters, only when Codex is signed in with the ChatGPT subscription
   (`codex login` → sign in with ChatGPT). If its auth file shows an API key, nothing is attributed
   to the individual account: that spend belongs to the organization connection.
 
-Each user on a computer reports **one** connection: a second `login` with another token replaces
-the first. Usage from before `login` is never uploaded.
+Each user on a computer can report **one connection per tool**: run `login` once with each token,
+for example the Claude Code one and the Cursor one, and both report. A second token for the same
+tool replaces the first, because the local usage of a tool does not say which account it came from.
+Usage from before `login` is never uploaded.
 
 ## Reading the figures
 
@@ -296,10 +309,11 @@ start uses the Node that `login` ran with.
 
 | Command | What it does |
 | --- | --- |
-| `sentinel-usage login` | Stores the token read from standard input, installs the Cursor hook and registers the startup task. If any step fails, nothing is left installed |
-| `sentinel-usage report` | Uploads the usage that is new since the last accepted day. Run by the startup task; safe to run by hand |
-| `sentinel-usage status` | Says whether the agent and the startup task are installed, which tool this connection reports, and the last accepted day. It does not print the token |
-| `sentinel-usage logout` | Removes the startup task, the Cursor hook and the token from this machine |
+| `sentinel-usage login` | Adds the token read from standard input, installs the Cursor hook and registers the startup task. A token for a tool already reported replaces it. If any step fails, nothing is left installed |
+| `sentinel-usage report` | Uploads, for each connection, the usage that is new since its last accepted day. Run by the startup task; safe to run by hand |
+| `sentinel-usage status` | Says whether the agent and the startup task are installed and, for each connection, which tool it reports and its last accepted day. It does not print tokens |
+| `sentinel-usage logout` | Removes every connection, the startup task, the Cursor hook and the status line from this machine |
+| `sentinel-usage logout cursor` | Removes only that tool (`cursor`, `claude_code`, `github_copilot` or `codex`); the others keep reporting |
 
 ## Environment variables
 
@@ -313,6 +327,7 @@ macOS and Linux it does not read the variables of your shell.
 | `SENTINEL_USAGE_CURSOR_HOOKS` | Path of Cursor's hooks file. Defaults to `~/.cursor/hooks.json` |
 | `SENTINEL_USAGE_CLAUDE_DIR` | Claude Code projects folder. Defaults to `projects` under `CLAUDE_CONFIG_DIR` or `~/.claude` |
 | `SENTINEL_USAGE_CODEX_HOME` | Codex folder. Defaults to `CODEX_HOME` or `~/.codex` |
+| `SENTINEL_USAGE_NO_STATUSLINE` | With `1`, the Claude Code status line is not set and its quota headroom is not measured |
 
 The token is stored in `usage.json` inside `SENTINEL_USAGE_HOME`. On macOS and Linux the file is
 readable only by your user (mode 600); on Windows it inherits the permissions of your profile

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { execFile } from "node:child_process";
 import { homedir, userInfo } from "node:os";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname3, join as join5 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
@@ -63,7 +63,7 @@ ${args.map(cmdArg).join(" ")}\r
   <Actions Context="Author"><Exec><Command>${xmlEscape(windowsCmd)}</Command></Exec></Actions>\r
 </Task>\r
 `;
-          writeFileSync(logonXml, Buffer.from(`\uFEFF${xml}`, "utf16le"));
+          writeFileSync(logonXml, Buffer.from(`${String.fromCharCode(65279)}${xml}`, "utf16le"));
           try {
             await run(exec, "schtasks", ["/Create", "/F", "/TN", TASK_LOGON, "/XML", logonXml]);
           } finally {
@@ -188,10 +188,144 @@ WantedBy=timers.target
   };
 }
 
+// src/quota.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+
+// src/bom.ts
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+
+// src/quota.ts
+import { dirname } from "node:path";
+var MAX_RESETS_PER_DAY = 48;
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readQuotaState(path) {
+  if (!existsSync2(path)) return { days: {} };
+  try {
+    const root = asRecord(JSON.parse(readFileSync2(path, "utf8")));
+    const days = {};
+    for (const [day, raw] of Object.entries(asRecord(root?.["days"]) ?? {})) {
+      const entry = asRecord(raw);
+      if (!entry || !/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
+      const parsed = {};
+      const five = num(entry["fiveHourPeak"]);
+      const seven = num(entry["sevenDayPeak"]);
+      if (five !== void 0) parsed.fiveHourPeak = five;
+      if (seven !== void 0) parsed.sevenDayPeak = seven;
+      const resets = entry["fiveHourLimitResets"];
+      if (Array.isArray(resets)) {
+        const valid = resets.filter((end) => typeof end === "number" && Number.isInteger(end) && end > 0);
+        if (valid.length > 0) parsed.fiveHourLimitResets = valid.slice(-MAX_RESETS_PER_DAY);
+      }
+      days[day] = parsed;
+    }
+    const lastRaw = asRecord(root?.["last"]);
+    const state = { days };
+    if (lastRaw) {
+      const last = {};
+      const five = num(lastRaw["fiveHour"]);
+      const seven = num(lastRaw["sevenDay"]);
+      if (five !== void 0) last.fiveHour = five;
+      if (seven !== void 0) last.sevenDay = seven;
+      state.last = last;
+    }
+    return state;
+  } catch {
+    return { days: {} };
+  }
+}
+function writeQuotaState(path, state) {
+  mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync2(temp, `${JSON.stringify(state)}
+`, { mode: 384 });
+  renameSync(temp, path);
+}
+function recordStatusSample(state, input, now) {
+  const limits = asRecord(asRecord(input)?.["rate_limits"]);
+  if (!limits) return false;
+  const fiveHour = asRecord(limits["five_hour"]);
+  const sevenDay = asRecord(limits["seven_day"]);
+  const five = num(fiveHour?.["used_percentage"]);
+  const seven = num(sevenDay?.["used_percentage"]);
+  if (five === void 0 && seven === void 0) return false;
+  const day = now.toISOString().slice(0, 10);
+  const entry = state.days[day] ?? {};
+  const before = JSON.stringify(entry);
+  if (five !== void 0) entry.fiveHourPeak = Math.max(entry.fiveHourPeak ?? 0, five);
+  if (seven !== void 0) entry.sevenDayPeak = Math.max(entry.sevenDayPeak ?? 0, seven);
+  const resetsAt = num(fiveHour?.["resets_at"]);
+  if (five !== void 0 && five >= 100 && resetsAt !== void 0 && Number.isInteger(resetsAt)) {
+    const resets = new Set(entry.fiveHourLimitResets ?? []);
+    resets.add(resetsAt);
+    entry.fiveHourLimitResets = [...resets].slice(-MAX_RESETS_PER_DAY);
+  }
+  state.days[day] = entry;
+  const lastBefore = JSON.stringify(state.last ?? {});
+  state.last = {
+    ...five !== void 0 ? { fiveHour: five } : state.last?.fiveHour !== void 0 ? { fiveHour: state.last.fiveHour } : {},
+    ...seven !== void 0 ? { sevenDay: seven } : state.last?.sevenDay !== void 0 ? { sevenDay: state.last.sevenDay } : {}
+  };
+  return JSON.stringify(entry) !== before || JSON.stringify(state.last) !== lastBefore;
+}
+function defaultStatusText(state) {
+  const parts = [];
+  if (state.last?.fiveHour !== void 0) parts.push(`5 h ${Math.round(state.last.fiveHour)} %`);
+  if (state.last?.sevenDay !== void 0) parts.push(`semana ${Math.round(state.last.sevenDay)} %`);
+  return parts.join(" \xB7 ");
+}
+function statusLineCommand(args, platform) {
+  return args.map((arg) => platform === "win32" ? arg.replaceAll("\\", "/") : arg).map((arg) => `"${arg.replaceAll('"', '\\"')}"`).join(" ");
+}
+function parseSettings(text) {
+  if (!text.trim()) return {};
+  try {
+    return asRecord(JSON.parse(stripBom(text)));
+  } catch {
+    return null;
+  }
+}
+function statusLineOf(root) {
+  const raw = asRecord(root["statusLine"]);
+  if (!raw || typeof raw["command"] !== "string") return void 0;
+  const setting = { type: typeof raw["type"] === "string" ? raw["type"] : "command", command: raw["command"] };
+  if (typeof raw["padding"] === "number") setting.padding = raw["padding"];
+  return setting;
+}
+function mergeClaudeStatusLine(existing, command) {
+  const root = parseSettings(existing);
+  if (!root) return { status: "unreadable" };
+  const previous = statusLineOf(root);
+  if (previous?.command === command) return { status: "already" };
+  const next = { ...root, statusLine: { type: "command", command, ...previous?.padding !== void 0 ? { padding: previous.padding } : {} } };
+  return { status: "installed", text: `${JSON.stringify(next, null, 2)}
+`, ...previous ? { previous } : {} };
+}
+function hasClaudeStatusLine(existing, command) {
+  const root = parseSettings(existing);
+  return root ? statusLineOf(root)?.command === command : false;
+}
+function removeClaudeStatusLine(existing, command, previous) {
+  const root = parseSettings(existing);
+  if (!root || statusLineOf(root)?.command !== command) return existing;
+  const next = { ...root };
+  if (previous) next["statusLine"] = { ...previous };
+  else delete next["statusLine"];
+  return `${JSON.stringify(next, null, 2)}
+`;
+}
+
 // src/session.ts
+import { spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, rmSync as rmSync2, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname, join as join4 } from "node:path";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, rmSync as rmSync2, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 
 // src/cursor.ts
 var MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
@@ -254,19 +388,19 @@ ${event.model ?? ""}`;
   }
   return byDay;
 }
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   return value;
 }
 function mergeCursorHook(existing, command) {
   let parsed = {};
-  if (existing.trim()) parsed = JSON.parse(existing);
-  const root = asRecord(parsed) ?? {};
-  const hooks = asRecord(root["hooks"]) ?? {};
+  if (existing.trim()) parsed = JSON.parse(stripBom(existing));
+  const root = asRecord2(parsed) ?? {};
+  const hooks = asRecord2(root["hooks"]) ?? {};
   const stopRaw = hooks["stop"];
-  const stop = Array.isArray(stopRaw) ? stopRaw.filter((entry) => asRecord(entry)?.["command"] !== command) : [];
+  const stop = Array.isArray(stopRaw) ? stopRaw.filter((entry) => asRecord2(entry)?.["command"] !== command) : [];
   const kept = stop.flatMap((entry) => {
-    const record = asRecord(entry);
+    const record = asRecord2(entry);
     if (!record || typeof record["command"] !== "string") return [];
     return [record];
   });
@@ -275,11 +409,11 @@ function mergeCursorHook(existing, command) {
 }
 function removeCursorHook(existing, command) {
   if (!existing.trim()) return existing;
-  const root = asRecord(JSON.parse(existing));
+  const root = asRecord2(JSON.parse(stripBom(existing)));
   if (!root) return existing;
-  const hooks = asRecord(root["hooks"]);
+  const hooks = asRecord2(root["hooks"]);
   if (!hooks || !Array.isArray(hooks["stop"])) return existing;
-  const stop = hooks["stop"].filter((entry) => asRecord(entry)?.["command"] !== command);
+  const stop = hooks["stop"].filter((entry) => asRecord2(entry)?.["command"] !== command);
   if (stop.length === 0) {
     const rest = {};
     for (const [key, value] of Object.entries(hooks)) {
@@ -574,7 +708,7 @@ function readClaudeIncrement(dir, previous) {
 }
 
 // src/codex.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, readSync as readSync2, statSync as statSync2 } from "node:fs";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, readSync as readSync2, statSync as statSync2 } from "node:fs";
 import { join as join3, relative as relative2 } from "node:path";
 var MODEL_PATTERN3 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
 var TOKEN_MAX3 = 1e12;
@@ -772,7 +906,7 @@ function readChunk2(path, offset) {
 }
 function readCodexAuth(home) {
   try {
-    return classifyCodexAuth(readFileSync2(join3(home, "auth.json"), "utf8"));
+    return classifyCodexAuth(readFileSync3(join3(home, "auth.json"), "utf8"));
   } catch {
     return "unknown";
   }
@@ -906,12 +1040,39 @@ async function ghJson(gh, path) {
     return { auth: false, payload: null };
   }
 }
-async function readCopilotDay(gh, day) {
+function creditsFromCopilotUsage(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return void 0;
+  const items = payload["usageItems"];
+  if (!Array.isArray(items)) return void 0;
+  let total = 0;
+  for (const item of items) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const record = item;
+    const unit = typeof record["unitType"] === "string" ? record["unitType"].toLowerCase() : "";
+    const quantity = typeof record["grossQuantity"] === "number" && Number.isFinite(record["grossQuantity"]) && record["grossQuantity"] >= 0 ? record["grossQuantity"] : void 0;
+    if (unit.includes("credit") && quantity !== void 0) total += quantity;
+  }
+  return total;
+}
+async function copilotLogin(gh) {
   const user = await ghJson(gh, "user");
   if (user.auth) return { status: "auth" };
   if (!user.payload) return { status: "unavailable" };
   const login2 = user.payload && typeof user.payload === "object" && !Array.isArray(user.payload) ? user.payload["login"] : void 0;
   if (typeof login2 !== "string" || !/^[A-Za-z0-9-]{1,39}$/.test(login2)) return { status: "empty" };
+  return { status: "ok", login: login2 };
+}
+async function readCopilotMonthCredits(gh, day) {
+  const user = await copilotLogin(gh);
+  if (user.status !== "ok") return void 0;
+  const [year, month] = day.split("-");
+  const usage = await ghJson(gh, `/users/${user.login}/settings/billing/ai_credit/usage?year=${year}&month=${Number(month)}`);
+  return usage.payload ? creditsFromCopilotUsage(usage.payload) : void 0;
+}
+async function readCopilotDay(gh, day) {
+  const user = await copilotLogin(gh);
+  if (user.status !== "ok") return { status: user.status };
+  const login2 = user.login;
   const [year, month, date] = day.split("-");
   const query = `year=${year}&month=${Number(month)}&day=${Number(date)}`;
   const base = `/users/${login2}/settings/billing`;
@@ -975,7 +1136,8 @@ async function postTelemetry(options) {
         turns: row.turns,
         tokensKnown: row.tokensKnown,
         ...row.model ? { model: row.model } : {}
-      }))
+      })),
+      ...options.quota ? { quota: options.quota } : {}
     })
   });
   let code;
@@ -995,47 +1157,82 @@ var EXIT_REPORT = 4;
 var EXIT_COPILOT = 5;
 var MAX_ROWS = 40;
 var TOKEN_PATTERN = /^sau_[A-Za-z0-9_-]{20,200}$/;
+function parseStatusLineConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  if (record["state"] !== "installed" && record["state"] !== "declined") return void 0;
+  const config = { state: record["state"] };
+  const previous = record["previous"];
+  if (previous && typeof previous === "object" && !Array.isArray(previous)) {
+    const raw = previous;
+    if (typeof raw["command"] === "string") {
+      config.previous = {
+        type: typeof raw["type"] === "string" ? raw["type"] : "command",
+        command: raw["command"],
+        ...typeof raw["padding"] === "number" ? { padding: raw["padding"] } : {}
+      };
+    }
+  }
+  return config;
+}
 var DEVICE_PATTERN = /^[a-f0-9]{16}$/;
 function newDevice() {
   return randomBytes(8).toString("hex");
 }
-function readJson(path) {
-  if (!existsSync2(path)) return {};
+function parseConnection(record) {
+  if (typeof record["token"] !== "string") return null;
+  const connection = { token: record["token"] };
+  if (isUsageSource(record["source"])) connection.source = record["source"];
+  if (typeof record["addedAt"] === "string") connection.addedAt = record["addedAt"];
+  if (typeof record["lastAcceptedDay"] === "string") connection.lastAcceptedDay = record["lastAcceptedDay"];
+  if (record["claude"]) connection.claude = parseClaudeState(record["claude"]);
+  if (record["codex"]) connection.codex = parseCodexState(record["codex"]);
+  return connection;
+}
+function readConfig(path) {
+  if (!existsSync3(path)) return { connections: [] };
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { connections: [] };
     const record = parsed;
-    const config = {};
-    if (typeof record["token"] === "string") config.token = record["token"];
+    const config = { connections: [] };
     if (typeof record["device"] === "string" && DEVICE_PATTERN.test(record["device"])) config.device = record["device"];
-    if (typeof record["lastAcceptedDay"] === "string") config.lastAcceptedDay = record["lastAcceptedDay"];
-    if (record["claude"]) config.claude = parseClaudeState(record["claude"]);
-    if (record["codex"]) config.codex = parseCodexState(record["codex"]);
-    if (isUsageSource(record["source"])) config.source = record["source"];
+    if (Array.isArray(record["connections"])) {
+      for (const entry of record["connections"]) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+        const connection = parseConnection(entry);
+        if (connection) config.connections.push(connection);
+      }
+    } else {
+      const legacy = parseConnection(record);
+      if (legacy) config.connections.push(legacy);
+    }
+    const statusLine2 = parseStatusLineConfig(record["claudeStatusLine"]);
+    if (statusLine2) config.claudeStatusLine = statusLine2;
     return config;
   } catch {
-    return {};
+    return { connections: [] };
   }
 }
-function writeJson(path, value) {
-  mkdirSync2(dirname(path), { recursive: true, mode: 448 });
-  writeFileSync2(path, `${JSON.stringify(value)}
+function writeConfig(path, value) {
+  mkdirSync3(dirname2(path), { recursive: true, mode: 448 });
+  writeFileSync3(path, `${JSON.stringify({ version: 2, ...value })}
 `, { mode: 384 });
   chmodSync(path, 384);
 }
 function restoreFile(path, previous) {
   if (previous === null) {
-    if (existsSync2(path)) unlinkSync(path);
+    if (existsSync3(path)) unlinkSync(path);
     return;
   }
-  writeFileSync2(path, previous);
+  writeFileSync3(path, previous);
 }
 function readSpool(dir) {
-  if (!existsSync2(dir)) return [];
+  if (!existsSync3(dir)) return [];
   return readdirSync3(dir).filter((name) => name.endsWith(".json")).map((name) => {
     const path = join4(dir, name);
     try {
-      return { path, event: readSpoolEvent(JSON.parse(readFileSync3(path, "utf8"))) };
+      return { path, event: readSpoolEvent(JSON.parse(readFileSync4(path, "utf8"))) };
     } catch {
       return { path, event: null };
     }
@@ -1047,27 +1244,46 @@ function utcDay(date) {
 function clearSpool(dir) {
   rmSync2(dir, { recursive: true, force: true });
 }
+function forgetLocalState(paths, source) {
+  if (source === "cursor") clearSpool(paths.spoolPath);
+  if (source === "claude_code" && paths.quotaPath) rmSync2(paths.quotaPath, { force: true });
+}
 async function login(options) {
-  const token = options.token.replace(/^\uFEFF/, "").trim();
+  const token = stripBom(options.token).trim();
   if (!TOKEN_PATTERN.test(token)) {
     return { code: EXIT_USAGE, message: "El token no tiene el formato de un alta de uso." };
   }
-  const previousConfig = existsSync2(options.paths.configPath) ? readFileSync3(options.paths.configPath, "utf8") : null;
-  const previousHooks = existsSync2(options.paths.hooksPath) ? readFileSync3(options.paths.hooksPath, "utf8") : null;
-  const config = readJson(options.paths.configPath);
-  const tokenChanged = config.token !== void 0 && config.token !== token;
-  const next = { token, device: config.device ?? newDevice() };
-  if (config.lastAcceptedDay) next.lastAcceptedDay = config.lastAcceptedDay;
-  const since = utcDay(options.now ?? /* @__PURE__ */ new Date());
-  next.claude = config.claude && !tokenChanged ? config.claude : emptyClaudeState(since);
-  next.codex = config.codex && !tokenChanged ? config.codex : emptyCodexState(since);
-  if (config.source && !tokenChanged) next.source = config.source;
-  writeJson(options.paths.configPath, next);
+  const previousConfig = existsSync3(options.paths.configPath) ? readFileSync4(options.paths.configPath, "utf8") : null;
+  const previousHooks = existsSync3(options.paths.hooksPath) ? readFileSync4(options.paths.hooksPath, "utf8") : null;
+  const config = readConfig(options.paths.configPath);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const existing = config.connections.find((connection) => connection.token === token);
+  let source = existing?.source;
+  let replaced = [];
+  if (!existing) {
+    try {
+      source = await options.probe?.(token);
+    } catch {
+      source = void 0;
+    }
+    const since = utcDay(now);
+    const added = {
+      token,
+      addedAt: now.toISOString(),
+      claude: emptyClaudeState(since),
+      codex: emptyCodexState(since),
+      ...source ? { source } : {}
+    };
+    replaced = source ? config.connections.filter((connection) => connection.source === source) : [];
+    config.connections = [...config.connections.filter((connection) => !replaced.includes(connection)), added];
+  }
+  config.device = config.device ?? newDevice();
+  writeConfig(options.paths.configPath, config);
   try {
-    mkdirSync2(dirname(options.paths.hooksPath), { recursive: true });
-    writeFileSync2(options.paths.hooksPath, mergeCursorHook(previousHooks ?? "", options.hookCommand));
+    mkdirSync3(dirname2(options.paths.hooksPath), { recursive: true });
+    writeFileSync3(options.paths.hooksPath, mergeCursorHook(previousHooks ?? "", options.hookCommand));
     await options.launcher.install();
-    if (tokenChanged) clearSpool(options.paths.spoolPath);
+    if (replaced.length > 0) forgetLocalState(options.paths, source);
   } catch (err) {
     restoreFile(options.paths.configPath, previousConfig);
     restoreFile(options.paths.hooksPath, previousHooks);
@@ -1077,72 +1293,108 @@ async function login(options) {
       message: launcherFailed ? `No se pudo registrar el arranque. No se ha dejado el token instalado. ${err.message}` : `No se pudo instalar el hook de Cursor. No se ha dejado el token instalado. ${err.message}`
     };
   }
-  return { code: 0, message: "Agente instalado. El arranque subir\xE1 el uso; no hace falta lanzarlo en cada sesi\xF3n." };
+  const tools = config.connections.map((connection) => connection.source ?? "sin comprobar").join(", ");
+  const replacedNote = replaced.length > 0 ? ` Sustituye a la conexi\xF3n anterior de ${source}.` : "";
+  return {
+    code: 0,
+    message: `Agente instalado. El arranque subir\xE1 el uso; no hace falta lanzarlo en cada sesi\xF3n.${replacedNote} Este ordenador informa de: ${tools}.`
+  };
 }
 async function logout(options) {
+  const config = readConfig(options.paths.configPath);
+  const leaving = options.source ? config.connections.filter((connection) => connection.source === options.source) : config.connections;
+  if (options.source && leaving.length === 0) {
+    return { code: EXIT_USAGE, message: `Este ordenador no informa de ${options.source}.` };
+  }
+  const staying = config.connections.filter((connection) => !leaving.includes(connection));
   let launcherError;
-  try {
-    await options.launcher.uninstall();
-  } catch (err) {
-    launcherError = err;
+  if (staying.length === 0) {
+    try {
+      await options.launcher.uninstall();
+    } catch (err) {
+      launcherError = err;
+    }
   }
   let hookError = false;
-  if (existsSync2(options.paths.hooksPath)) {
-    try {
-      const current = readFileSync3(options.paths.hooksPath, "utf8");
-      writeFileSync2(options.paths.hooksPath, removeCursorHook(current, options.hookCommand));
-    } catch {
-      hookError = true;
+  const keepsCursor = staying.some((connection) => connection.source === "cursor" || !connection.source);
+  if (!keepsCursor) {
+    if (existsSync3(options.paths.hooksPath)) {
+      try {
+        const current = readFileSync4(options.paths.hooksPath, "utf8");
+        writeFileSync3(options.paths.hooksPath, removeCursorHook(current, options.hookCommand));
+      } catch {
+        hookError = true;
+      }
     }
+    clearSpool(options.paths.spoolPath);
   }
-  clearSpool(options.paths.spoolPath);
-  const config = readJson(options.paths.configPath);
-  if (config.token || config.lastAcceptedDay) {
-    const next = {};
-    if (config.lastAcceptedDay) next.lastAcceptedDay = config.lastAcceptedDay;
-    writeJson(options.paths.configPath, next);
+  const next = { ...config.device ? { device: config.device } : {}, connections: staying };
+  const keepsClaude = staying.some((connection) => connection.source === "claude_code" || !connection.source);
+  if (keepsClaude) {
+    if (config.claudeStatusLine) next.claudeStatusLine = config.claudeStatusLine;
+  } else {
+    if (config.claudeStatusLine?.state === "installed") {
+      restoreClaudeStatusLine(options.paths, options.statusLineCommand, config.claudeStatusLine.previous);
+    }
+    if (options.paths.quotaPath) rmSync2(options.paths.quotaPath, { force: true });
   }
+  if (existsSync3(options.paths.configPath) || staying.length > 0) writeConfig(options.paths.configPath, next);
   if (launcherError) {
     return { code: EXIT_LAUNCHER, message: `No se pudo quitar el arranque. ${launcherError.message}` };
   }
   if (hookError) {
     return { code: EXIT_USAGE, message: "El arranque se quit\xF3, pero el hook de Cursor no: su fichero no es JSON." };
   }
+  if (staying.length > 0) {
+    return { code: 0, message: `Conexi\xF3n retirada. Este ordenador sigue informando de: ${staying.map((connection) => connection.source ?? "sin comprobar").join(", ")}.` };
+  }
   return { code: 0, message: "Agente retirado." };
 }
 function dropCursorHook(paths, hookCommand) {
-  if (!hookCommand || !existsSync2(paths.hooksPath)) return;
+  if (!hookCommand || !existsSync3(paths.hooksPath)) return;
   try {
-    const current = readFileSync3(paths.hooksPath, "utf8");
+    const current = readFileSync4(paths.hooksPath, "utf8");
     const next = removeCursorHook(current, hookCommand);
-    if (next !== current) writeFileSync2(paths.hooksPath, next);
+    if (next !== current) writeFileSync3(paths.hooksPath, next);
   } catch {
   }
 }
-async function report(options) {
-  const config = readJson(options.paths.configPath);
-  const token = config.token;
-  if (!token) return { code: EXIT_USAGE, message: "No hay token. Hay que hacer login en esta conexi\xF3n." };
-  const device = config.device ?? newDevice();
-  const baseUrl = resolveUsageBaseUrl(options.baseUrl);
-  if (!baseUrl) return { code: EXIT_USAGE, message: "La URL del API tiene que ser https." };
-  const today = utcDay(options.now ?? /* @__PURE__ */ new Date());
-  const probe = await fetchUsageSource({ baseUrl, token, fetchImpl: options.fetchImpl });
-  if (probe.status === 401) {
-    return { code: EXIT_REPORT, message: "El servidor no reconoce el token. Hay que repetir el login con un token nuevo." };
+function restoreClaudeStatusLine(paths, command, previous) {
+  if (!command || !paths.claudeSettingsPath || !existsSync3(paths.claudeSettingsPath)) return;
+  try {
+    const current = readFileSync4(paths.claudeSettingsPath, "utf8");
+    const next = removeClaudeStatusLine(current, command, previous);
+    if (next !== current) writeFileSync3(paths.claudeSettingsPath, next);
+  } catch {
   }
-  const source = probe.source ?? config.source;
-  if (!source) {
-    return { code: EXIT_REPORT, message: `No se pudo saber qu\xE9 herramienta informa esta conexi\xF3n (${probe.status}). Se reintentar\xE1.` };
+}
+function ensureClaudeStatusLine(paths, command, current) {
+  const settingsPath = paths.claudeSettingsPath;
+  if (!command || !settingsPath || current?.state === "declined") return current;
+  try {
+    const text = existsSync3(settingsPath) ? readFileSync4(settingsPath, "utf8") : "";
+    if (current?.state === "installed") {
+      return hasClaudeStatusLine(text, command) ? current : { state: "declined", ...current.previous ? { previous: current.previous } : {} };
+    }
+    const merged = mergeClaudeStatusLine(text, command);
+    if (merged.status === "unreadable") return current;
+    if (merged.status === "already") return { state: "installed" };
+    mkdirSync3(dirname2(settingsPath), { recursive: true });
+    writeFileSync3(settingsPath, merged.text);
+    return { state: "installed", ...merged.previous ? { previous: merged.previous } : {} };
+  } catch {
+    return current;
   }
-  const files = readSpool(options.paths.spoolPath);
+}
+async function reportConnection(options, connection, source, context) {
+  const { baseUrl, device, today } = context;
+  const token = connection.token;
   const accepted = /* @__PURE__ */ new Set();
   const outcome = { error: void 0, mismatch: false, acceptedAny: false };
-  let lastAccepted = config.lastAcceptedDay;
-  let claudeState = config.claude;
-  let codexState = config.codex;
-  const send = async (day, rows, kept) => {
-    if (rows.length === 0) return "skip";
+  let lastAccepted = connection.lastAcceptedDay;
+  let statusLine2 = context.statusLine;
+  const send = async (day, rows, kept, quota) => {
+    if (rows.length === 0 && !quota) return "skip";
     if (rows.length > MAX_ROWS) {
       outcome.error = `El d\xEDa ${day} tiene m\xE1s de ${MAX_ROWS} modelos y no se ha subido.`;
       return "stop";
@@ -1154,7 +1406,8 @@ async function report(options) {
       rows,
       fetchImpl: options.fetchImpl,
       source,
-      ...source === "github_copilot" ? {} : { device }
+      ...source === "github_copilot" ? {} : { device },
+      ...quota ? { quota } : {}
     });
     if (result.ok) {
       outcome.acceptedAny = true;
@@ -1174,24 +1427,32 @@ async function report(options) {
   let copilotUnavailable = false;
   let codexAuth;
   if (source === "cursor") {
-    const byDay = aggregateByDay(files.flatMap((file) => file.event ? [file.event] : []));
+    const byDay = aggregateByDay(context.spool.flatMap((file) => file.event ? [file.event] : []));
     for (const day of [...byDay.keys()].sort()) {
       if (await send(day, byDay.get(day) ?? [], " El spool de ese d\xEDa sigue en el port\xE1til.") === "stop") break;
     }
   } else if (source === "claude_code") {
+    statusLine2 = ensureClaudeStatusLine(options.paths, options.statusLineCommand, statusLine2);
     const claudeDir = options.claudeProjectsDir;
-    const ready = claudeDir && existsSync2(claudeDir) ? readClaudeIncrement(claudeDir, config.claude ?? emptyClaudeState(today)) : null;
-    if (ready) {
-      for (const day of ready.dirtyDays) {
-        if (await send(day, rowsForDay(ready.state.days, day), " La transcripci\xF3n sigue en el port\xE1til.") === "stop") break;
-      }
-      if (!outcome.error) {
-        claudeState = ready.state;
-        if (ready.caughtUp) pruneClaudeDays(claudeState, previousUtcDay(today));
-      }
+    const ready = claudeDir && existsSync3(claudeDir) ? readClaudeIncrement(claudeDir, connection.claude ?? emptyClaudeState(today)) : null;
+    const quotaDays = options.paths.quotaPath ? readQuotaState(options.paths.quotaPath).days : {};
+    const days = [.../* @__PURE__ */ new Set([...ready?.dirtyDays ?? [], ...Object.keys(quotaDays)])].sort();
+    for (const day of days) {
+      const rows = ready ? rowsForDay(ready.state.days, day) : [];
+      if (await send(day, rows, " La transcripci\xF3n sigue en el port\xE1til.", quotaDays[day]) === "stop") break;
+    }
+    if (ready && !outcome.error) {
+      connection.claude = ready.state;
+      if (ready.caughtUp) pruneClaudeDays(connection.claude, previousUtcDay(today));
+    }
+    if (options.paths.quotaPath && accepted.size > 0) {
+      const fresh = readQuotaState(options.paths.quotaPath);
+      for (const day of Object.keys(fresh.days)) if (day < today && accepted.has(day)) delete fresh.days[day];
+      writeQuotaState(options.paths.quotaPath, fresh);
     }
   } else if (source === "github_copilot") {
     if (options.gh) {
+      const credits = await readCopilotMonthCredits(options.gh, today);
       for (const day of [previousUtcDay(today), today]) {
         const read = await readCopilotDay(options.gh, day);
         if (read.status === "auth") {
@@ -1202,78 +1463,183 @@ async function report(options) {
           copilotUnavailable = true;
           break;
         }
-        if (read.status !== "rows") continue;
-        if (await send(day, read.rows, "") === "stop") break;
+        const quota = day === today && credits !== void 0 ? { monthAiCredits: credits } : void 0;
+        if (read.status !== "rows" && !quota) continue;
+        if (await send(day, read.status === "rows" ? read.rows : [], "", quota) === "stop") break;
       }
     }
   } else {
     const codexHome2 = options.codexHome;
-    if (codexHome2 && existsSync2(codexHome2)) {
+    if (codexHome2 && existsSync3(codexHome2)) {
       const auth = readCodexAuth(codexHome2);
       const sessions = join4(codexHome2, "sessions");
       if (auth !== "chatgpt") codexAuth = auth;
-      else if (existsSync2(sessions)) {
-        const ready = readCodexIncrement(sessions, codexState ?? emptyCodexState(today));
+      else if (existsSync3(sessions)) {
+        const ready = readCodexIncrement(sessions, connection.codex ?? emptyCodexState(today));
         for (const day of ready.dirtyDays) {
           if (await send(day, rowsForCodexDay(ready.state.days, day), " La sesi\xF3n sigue en el port\xE1til.") === "stop") break;
         }
         if (!outcome.error) {
-          codexState = ready.state;
+          connection.codex = ready.state;
           if (ready.caughtUp) {
             const before = previousUtcDay(today);
-            for (const day of Object.keys(codexState.days)) {
-              if (day < before) delete codexState.days[day];
+            for (const day of Object.keys(connection.codex.days)) {
+              if (day < before) delete connection.codex.days[day];
             }
           }
         }
       }
     }
   }
-  const dropSpool = source !== "cursor" || outcome.mismatch;
-  if (dropSpool) dropCursorHook(options.paths, options.hookCommand);
-  for (const file of files) {
-    const day = file.event?.at.slice(0, 10);
-    if (dropSpool || day && day < today && accepted.has(day)) unlinkSync(file.path);
-  }
-  const next = { token, device };
-  if (lastAccepted) next.lastAcceptedDay = lastAccepted;
-  if (claudeState) next.claude = claudeState;
-  if (codexState) next.codex = codexState;
-  if (!outcome.mismatch) next.source = source;
-  writeJson(options.paths.configPath, next);
-  if (outcome.error) return { code: EXIT_REPORT, message: outcome.error };
-  if (outcome.mismatch) {
-    return { code: 0, message: "El uso de esta herramienta no corresponde a esta conexi\xF3n y no se ha subido." };
-  }
+  if (lastAccepted) connection.lastAcceptedDay = lastAccepted;
+  if (!outcome.mismatch) connection.source = source;
+  const run2 = (result) => ({
+    connection,
+    source,
+    result,
+    mismatch: outcome.mismatch,
+    accepted,
+    ...statusLine2 ? { statusLine: statusLine2 } : {}
+  });
+  if (outcome.error) return run2({ code: EXIT_REPORT, message: outcome.error });
+  if (outcome.mismatch) return run2({ code: 0, message: "El uso de esta herramienta no corresponde a esta conexi\xF3n y no se ha subido." });
   if (copilotAuth && !outcome.acceptedAny) {
-    return { code: EXIT_COPILOT, message: "gh no tiene permiso para leer el uso de Copilot. No se ha escrito una fila vac\xEDa." };
+    return run2({ code: EXIT_COPILOT, message: "gh no tiene permiso para leer el uso de Copilot. No se ha escrito una fila vac\xEDa." });
   }
   if (copilotUnavailable) {
-    return { code: EXIT_COPILOT, message: "No se pudo usar gh. Hace falta GitHub CLI con gh auth login en la cuenta de Copilot." };
+    return run2({ code: EXIT_COPILOT, message: "No se pudo usar gh. Hace falta GitHub CLI con gh auth login en la cuenta de Copilot." });
   }
   if (!outcome.acceptedAny) {
-    if (codexAuth === "api_key") {
-      return { code: 0, message: "Codex usa una API key. Ese gasto no se atribuye a la cuenta individual." };
+    if (codexAuth === "api_key") return run2({ code: 0, message: "Codex usa una API key. Ese gasto no se atribuye a la cuenta individual." });
+    if (codexAuth === "unknown") return run2({ code: 0, message: "No se pudo confirmar que Codex use la suscripci\xF3n de ChatGPT. No se ha subido nada." });
+    return run2({ code: 0, message: "No hay uso nuevo que subir." });
+  }
+  return run2({ code: 0, message: `Uso aceptado hasta ${lastAccepted ?? "hoy"}.` });
+}
+async function report(options) {
+  const config = readConfig(options.paths.configPath);
+  if (config.connections.length === 0) return { code: EXIT_USAGE, message: "No hay token. Hay que hacer login en esta conexi\xF3n." };
+  const device = config.device ?? newDevice();
+  const baseUrl = resolveUsageBaseUrl(options.baseUrl);
+  if (!baseUrl) return { code: EXIT_USAGE, message: "La URL del API tiene que ser https." };
+  const today = utcDay(options.now ?? /* @__PURE__ */ new Date());
+  const resolved = [];
+  for (const connection of config.connections) {
+    const probe = await fetchUsageSource({ baseUrl, token: connection.token, fetchImpl: options.fetchImpl });
+    if (probe.status === 401) {
+      resolved.push({
+        connection,
+        ...connection.source ? { source: connection.source } : {},
+        failure: { code: EXIT_REPORT, message: "El servidor no reconoce el token. Hay que repetir el login con un token nuevo." }
+      });
+      continue;
+    }
+    const source = probe.source ?? connection.source;
+    resolved.push(
+      source ? { connection, source } : { connection, failure: { code: EXIT_REPORT, message: `No se pudo saber qu\xE9 herramienta informa esta conexi\xF3n (${probe.status}). Se reintentar\xE1.` } }
+    );
+  }
+  const kept = [];
+  const dropped = [];
+  for (let index = resolved.length - 1; index >= 0; index--) {
+    const entry = resolved[index];
+    if (entry.source && kept.some((other) => !other.failure && other.source === entry.source)) dropped.push(entry);
+    else kept.unshift(entry);
+  }
+  let spool = readSpool(options.paths.spoolPath);
+  for (const entry of dropped) {
+    if (entry.source !== "cursor") continue;
+    const winner = kept.find((other) => other.source === "cursor")?.connection.addedAt;
+    for (const file of spool) {
+      if (!winner || !file.event || file.event.at < winner) unlinkSync(file.path);
     }
-    if (codexAuth === "unknown") {
-      return { code: 0, message: "No se pudo confirmar que Codex use la suscripci\xF3n de ChatGPT. No se ha subido nada." };
+    spool = readSpool(options.paths.spoolPath);
+  }
+  const runs = [];
+  const failures = [];
+  let statusLine2 = config.claudeStatusLine;
+  for (const entry of kept) {
+    if (entry.failure || !entry.source) {
+      failures.push({ ...entry.source ? { source: entry.source } : {}, result: entry.failure });
+      continue;
     }
-    return { code: 0, message: "No hay uso nuevo que subir." };
+    const run2 = await reportConnection(options, entry.connection, entry.source, {
+      baseUrl,
+      device,
+      today,
+      spool,
+      ...statusLine2 ? { statusLine: statusLine2 } : {}
+    });
+    if (entry.source === "claude_code") statusLine2 = run2.statusLine;
+    runs.push(run2);
   }
-  return { code: 0, message: `Uso aceptado hasta ${lastAccepted ?? "hoy"}.` };
+  const pending = kept.some((entry) => !entry.source);
+  const cursorRun = runs.find((run2) => run2.source === "cursor" && !run2.mismatch);
+  const keepsCursor = pending || kept.some((entry) => entry.source === "cursor" && (entry.failure || !runs.find((run2) => run2.connection === entry.connection)?.mismatch));
+  if (!keepsCursor) dropCursorHook(options.paths, options.hookCommand);
+  for (const file of spool) {
+    const day = file.event?.at.slice(0, 10);
+    if (!keepsCursor || cursorRun && day && day < today && cursorRun.accepted.has(day)) unlinkSync(file.path);
+  }
+  const keepsClaude = pending || kept.some((entry) => entry.source === "claude_code" && (entry.failure || !runs.find((run2) => run2.connection === entry.connection)?.mismatch));
+  if (!keepsClaude && statusLine2?.state === "installed") {
+    restoreClaudeStatusLine(options.paths, options.statusLineCommand, statusLine2.previous);
+    statusLine2 = void 0;
+  }
+  const next = { device, connections: kept.map((entry) => entry.connection) };
+  if (statusLine2) next.claudeStatusLine = statusLine2;
+  writeConfig(options.paths.configPath, next);
+  const all = [
+    ...dropped.map((entry) => ({ source: entry.source, result: { code: 0, message: "Sustituida por un login m\xE1s reciente de la misma herramienta." } })),
+    ...failures,
+    ...runs.map((run2) => ({ source: run2.source, result: run2.result }))
+  ];
+  if (all.length === 1) return all[0].result;
+  return {
+    code: all.find((entry) => entry.result.code !== 0)?.result.code ?? 0,
+    message: all.map((entry) => `${entry.source ?? "sin comprobar"}: ${entry.result.message}`).join("\n")
+  };
 }
 function previousUtcDay(day) {
   return new Date(Date.parse(`${day}T00:00:00Z`) - 864e5).toISOString().slice(0, 10);
 }
+var runPreviousWithShell = (command, input) => {
+  const result = spawnSync(command, { shell: process.env["SHELL"] || true, input, encoding: "utf8", timeout: 5e3, windowsHide: true });
+  return result.status === 0 && typeof result.stdout === "string" ? result.stdout : null;
+};
+function statusLine(options) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(stripBom(options.input));
+  } catch {
+    parsed = null;
+  }
+  let state = { days: {} };
+  if (options.paths.quotaPath) {
+    try {
+      state = readQuotaState(options.paths.quotaPath);
+      if (parsed && recordStatusSample(state, parsed, options.now)) writeQuotaState(options.paths.quotaPath, state);
+    } catch {
+    }
+  }
+  const previous = readConfig(options.paths.configPath).claudeStatusLine?.previous;
+  if (previous) {
+    const output = (options.runPrevious ?? runPreviousWithShell)(previous.command, options.input);
+    if (output !== null) return output;
+  }
+  return defaultStatusText(state);
+}
 async function status(options) {
-  const config = readJson(options.paths.configPath);
+  const config = readConfig(options.paths.configPath);
   const installed = await options.launcher.installed();
-  const lines = [
-    `agente: ${config.token ? "instalado" : "ausente"}`,
-    `arranque: ${installed ? "s\xED" : "no"}`,
-    `herramienta: ${config.source ?? "sin comprobar"}`,
-    `\xFAltimo d\xEDa aceptado: ${config.lastAcceptedDay ?? "ninguno"}`
-  ];
+  const lines = [`agente: ${config.connections.length > 0 ? "instalado" : "ausente"}`, `arranque: ${installed ? "s\xED" : "no"}`];
+  for (const connection of config.connections) {
+    lines.push(`herramienta: ${connection.source ?? "sin comprobar"}`, `\xFAltimo d\xEDa aceptado: ${connection.lastAcceptedDay ?? "ninguno"}`);
+    if (connection.source === "claude_code") {
+      const state = config.claudeStatusLine?.state;
+      lines.push(`l\xEDnea de estado de Claude Code: ${state === "installed" ? "puesta" : state === "declined" ? "retirada por ti, no se vuelve a poner" : "no"}`);
+    }
+  }
   return { code: 0, message: lines.join("\n") };
 }
 
@@ -1289,14 +1655,24 @@ function nodeExec(file, args) {
     })
   );
 }
+function claudeConfigDir() {
+  return process.env["CLAUDE_CONFIG_DIR"] ?? join5(homedir(), ".claude");
+}
 function pathsFromEnv() {
   const home = process.env["SENTINEL_USAGE_HOME"] ?? join5(homedir(), ".config", "aaa-sentinel");
   return {
     configPath: join5(home, "usage.json"),
     spoolPath: join5(home, "spool"),
-    hooksPath: process.env["SENTINEL_USAGE_CURSOR_HOOKS"] ?? join5(homedir(), ".cursor", "hooks.json")
+    hooksPath: process.env["SENTINEL_USAGE_CURSOR_HOOKS"] ?? join5(homedir(), ".cursor", "hooks.json"),
+    quotaPath: join5(home, "claude-quota.json"),
+    claudeSettingsPath: process.env["SENTINEL_USAGE_CLAUDE_SETTINGS"] ?? join5(claudeConfigDir(), "settings.json")
   };
 }
+function statusLineArgs() {
+  if (process.env["SENTINEL_USAGE_NO_STATUSLINE"] === "1") return null;
+  const cliJs = fileURLToPath(new URL("./cli.js", import.meta.url));
+  return [process.execPath, cliJs, "statusline"];
+}
 function codexHome() {
   return process.env["SENTINEL_USAGE_CODEX_HOME"] || process.env["CODEX_HOME"] || join5(homedir(), ".codex");
 }
@@ -1312,7 +1688,7 @@ function ghRun(args) {
 }
 function claudeProjectsDir() {
   if (process.env["SENTINEL_USAGE_CLAUDE_DIR"]) return process.env["SENTINEL_USAGE_CLAUDE_DIR"];
-  return join5(process.env["CLAUDE_CONFIG_DIR"] ?? join5(homedir(), ".claude"), "projects");
+  return join5(claudeConfigDir(), "projects");
 }
 function hookArgs(spoolPath) {
   const hookJs = fileURLToPath(new URL("./hook.js", import.meta.url));
@@ -1325,7 +1701,13 @@ function reportArgs() {
 async function main() {
   const [command, tokenArg] = [process.argv[2], process.argv[3]];
   const paths = pathsFromEnv();
+  if (command === "statusline") {
+    process.stdout.write(statusLine({ input: await readStdin(), paths, now: /* @__PURE__ */ new Date() }));
+    return 0;
+  }
   const hookCommand = formatCommand(hookArgs(paths.spoolPath));
+  const statusArgs = statusLineArgs();
+  const statusLineCommand2 = statusArgs ? statusLineCommand(statusArgs, process.platform) : void 0;
   const uid = process.getuid?.();
   const launcher = createLauncher({
     platform: process.platform,
@@ -1333,7 +1715,7 @@ async function main() {
     // El hook solo escribe el spool. Si la tarea lo relanza, el informe no sale del portátil.
     args: reportArgs(),
     homeDir: homedir(),
-    scriptDir: dirname2(paths.configPath),
+    scriptDir: dirname3(paths.configPath),
     ...uid !== void 0 ? { uid } : {},
     windowsUser: process.env.USERDOMAIN ? `${process.env.USERDOMAIN}\\${userInfo().username}` : userInfo().username
   });
@@ -1347,17 +1729,28 @@ async function main() {
       return 2;
     }
     const token = (await readStdin()).trim();
-    const result = await login({ token, paths, launcher, hookCommand });
+    const probe = sourceProbe();
+    const result = await login({ token, paths, launcher, hookCommand, ...probe ? { probe } : {} });
     console.log(result.message);
     return result.code;
   }
   if (command === "logout") {
-    const result = await logout({ paths, launcher, hookCommand });
+    if (tokenArg && !isUsageSource(tokenArg)) {
+      console.log("Herramienta desconocida. Usa cursor, claude_code, github_copilot o codex, o nada para retirarlas todas.");
+      return 2;
+    }
+    const result = await logout({
+      paths,
+      launcher,
+      hookCommand,
+      ...statusLineCommand2 ? { statusLineCommand: statusLineCommand2 } : {},
+      ...tokenArg && isUsageSource(tokenArg) ? { source: tokenArg } : {}
+    });
     console.log(result.message);
     return result.code;
   }
   if (command === "report") {
-    const baseUrl = process.env["SENTINEL_USAGE_BASE_URL"] ?? DEFAULT_BASE_URL;
+    const baseUrl = usageBaseUrl();
     const result = await report({
       paths,
       baseUrl,
@@ -1365,7 +1758,8 @@ async function main() {
       claudeProjectsDir: claudeProjectsDir(),
       codexHome: codexHome(),
       gh: ghRun,
-      hookCommand
+      hookCommand,
+      ...statusLineCommand2 ? { statusLineCommand: statusLineCommand2 } : {}
     });
     console.log(result.message);
     return result.code;
@@ -1375,9 +1769,17 @@ async function main() {
     console.log(result.message);
     return result.code;
   }
-  console.log("Uso: sentinel-usage login|logout|report|status");
+  console.log("Uso: sentinel-usage login|logout [herramienta]|report|status");
   return 2;
 }
+function usageBaseUrl() {
+  return process.env["SENTINEL_USAGE_BASE_URL"] ?? DEFAULT_BASE_URL;
+}
+function sourceProbe() {
+  const baseUrl = resolveUsageBaseUrl(usageBaseUrl());
+  if (!baseUrl) return void 0;
+  return async (token) => (await fetchUsageSource({ baseUrl, token, fetchImpl: fetch })).source;
+}
 function readStdin() {
   return new Promise((resolve, reject) => {
     const chunks = [];

package/dist/hook.js

@@ -1,8 +1,16 @@
 // src/hook.ts
+import { readFileSync } from "node:fs";
+
+// src/cursor.ts
 import { randomBytes } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+// src/bom.ts
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+
 // src/cursor.ts
 var MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
 var TOKEN_MAX = 1e12;
@@ -12,9 +20,9 @@ function finiteInt(value) {
   if (rounded > TOKEN_MAX) return void 0;
   return rounded;
 }
-function parseStopPayload(payload2, at) {
-  if (!payload2 || typeof payload2 !== "object" || Array.isArray(payload2)) return null;
-  const record = payload2;
+function parseStopPayload(payload, at) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
+  const record = payload;
   if (record["hook_event_name"] !== "stop") return null;
   const modelRaw = record["model"];
   const model = typeof modelRaw === "string" && MODEL_PATTERN.test(modelRaw) ? modelRaw : void 0;
@@ -22,25 +30,45 @@ function parseStopPayload(payload2, at) {
   const output = finiteInt(record["output_tokens"]);
   const cacheRead = finiteInt(record["cache_read_tokens"]);
   const cacheWrite = finiteInt(record["cache_write_tokens"]);
-  const event2 = { at, tokensKnown: false };
-  if (model) event2.model = model;
+  const event = { at, tokensKnown: false };
+  if (model) event.model = model;
   if (input !== void 0 && output !== void 0 && cacheRead !== void 0 && cacheWrite !== void 0) {
-    event2.tokensKnown = true;
-    event2.inputTokens = Math.max(0, input - cacheRead - cacheWrite);
-    event2.outputTokens = output;
-    event2.cacheReadTokens = cacheRead;
-    event2.cacheWriteTokens = cacheWrite;
+    event.tokensKnown = true;
+    event.inputTokens = Math.max(0, input - cacheRead - cacheWrite);
+    event.outputTokens = output;
+    event.cacheReadTokens = cacheRead;
+    event.cacheWriteTokens = cacheWrite;
   }
-  return event2;
+  return event;
 }
-function serializeSpoolEvent(event2) {
-  const line = { at: event2.at, tokensKnown: event2.tokensKnown };
-  if (event2.model) line["model"] = event2.model;
-  if (event2.tokensKnown) {
-    line["inputTokens"] = event2.inputTokens ?? 0;
-    line["outputTokens"] = event2.outputTokens ?? 0;
-    line["cacheReadTokens"] = event2.cacheReadTokens ?? 0;
-    line["cacheWriteTokens"] = event2.cacheWriteTokens ?? 0;
+function recordStop(raw2, spool2, at) {
+  let payload;
+  try {
+    payload = JSON.parse(stripBom(raw2));
+  } catch {
+    return false;
+  }
+  const event = parseStopPayload(payload, at);
+  if (!event) return false;
+  try {
+    mkdirSync(spool2, { recursive: true, mode: 448 });
+    writeFileSync(join(spool2, `${Date.now()}-${randomBytes(4).toString("hex")}.json`), serializeSpoolEvent(event), {
+      flag: "wx",
+      mode: 384
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function serializeSpoolEvent(event) {
+  const line = { at: event.at, tokensKnown: event.tokensKnown };
+  if (event.model) line["model"] = event.model;
+  if (event.tokensKnown) {
+    line["inputTokens"] = event.inputTokens ?? 0;
+    line["outputTokens"] = event.outputTokens ?? 0;
+    line["cacheReadTokens"] = event.cacheReadTokens ?? 0;
+    line["cacheWriteTokens"] = event.cacheWriteTokens ?? 0;
   }
   return JSON.stringify(line);
 }
@@ -48,20 +76,10 @@ function serializeSpoolEvent(event2) {
 // src/hook.ts
 var spool = process.argv[2];
 if (!spool) process.exit(0);
-var payload;
-try {
-  payload = JSON.parse(readFileSync(0, "utf8"));
-} catch {
-  process.exit(0);
-}
-var event = parseStopPayload(payload, (/* @__PURE__ */ new Date()).toISOString());
-if (!event) process.exit(0);
+var raw;
 try {
-  mkdirSync(spool, { recursive: true, mode: 448 });
-  writeFileSync(join(spool, `${Date.now()}-${randomBytes(4).toString("hex")}.json`), serializeSpoolEvent(event), {
-    flag: "wx",
-    mode: 384
-  });
+  raw = readFileSync(0, "utf8");
 } catch {
   process.exit(0);
 }
+recordStop(raw, spool, (/* @__PURE__ */ new Date()).toISOString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaa-sentinel/ai-usage",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Report individual Cursor, Claude Code, Copilot and Codex usage to AAA Sentinel; prompts and tokens stay on the laptop",
   "license": "MIT",
   "type": "module",