fleetlens 0.16.3 → 0.16.6

package/dist/daemon-worker.js

@@ -1525,11 +1525,11 @@ function defaultBranch(commonDir) {
   }
   return void 0;
 }
-function readGitFolder(path9) {
-  if (!existsSync(path9))
+function readGitFolder(path10) {
+  if (!existsSync(path10))
     return { exists: false, isWorktree: false };
   try {
-    const git = nearestDotGit(realpathOrSelf(path9));
+    const git = nearestDotGit(realpathOrSelf(path10));
     if (!git)
       return { exists: true, isWorktree: false };
     const projectRoot = projectRootFromCommonDir(git.commonDir);
@@ -5644,18 +5644,6 @@ var init_fs = __esm({
       },
       async getSession(id) {
         return getCodexSession(id);
-      },
-      async usagePoller() {
-        const w = await getLatestCodexUsage();
-        if (!w)
-          return null;
-        return {
-          captured_at: (/* @__PURE__ */ new Date()).toISOString(),
-          agent: "codex",
-          five_hour: w.five_hour,
-          seven_day: w.seven_day,
-          plan_type: w.plan_type
-        };
       }
     };
     geminiSource = {
@@ -5711,15 +5699,15 @@ var init_fs = __esm({
 });
 
 // src/usage/storage.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
 function appendSnapshot(filePath, snapshot) {
   mkdirSync3(dirname2(filePath), { recursive: true });
   appendFileSync2(filePath, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function readSnapshots(filePath) {
-  if (!existsSync5(filePath)) return [];
-  const content = readFileSync7(filePath, "utf8");
+  if (!existsSync6(filePath)) return [];
+  const content = readFileSync8(filePath, "utf8");
   const snapshots = [];
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -5731,8 +5719,8 @@ function readSnapshots(filePath) {
   return snapshots;
 }
 function pruneAgent(filePath, agent) {
-  if (!existsSync5(filePath)) return;
-  const kept = readFileSync7(filePath, "utf8").split("\n").filter((line) => {
+  if (!existsSync6(filePath)) return;
+  const kept = readFileSync8(filePath, "utf8").split("\n").filter((line) => {
     if (!line.trim()) return false;
     try {
       return JSON.parse(line).agent !== agent;
@@ -5741,7 +5729,7 @@ function pruneAgent(filePath, agent) {
     }
   });
   mkdirSync3(dirname2(filePath), { recursive: true });
-  writeFileSync3(filePath, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
+  writeFileSync4(filePath, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
 }
 function latestClaudeCodeSnapshot(filePath) {
   const all = readSnapshots(filePath);
@@ -6244,7 +6232,7 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join8, relative, resolve as resolve3, sep } from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -6254,15 +6242,15 @@ function pathHash(relPath) {
 function defaultScanRoots(extraRoots = []) {
   const roots = [];
   const home = join8(homedir3(), ".claude");
-  if (existsSync10(home)) roots.push({ root: home, label: "user" });
+  if (existsSync11(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
     const r = resolve3(e, ".claude");
-    if (existsSync10(r) && r !== home) roots.push({ root: r, label: "project" });
+    if (existsSync11(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync10(dir)) return [];
+  if (!existsSync11(dir)) return [];
   const out = [];
   let entries;
   try {
@@ -6332,7 +6320,7 @@ function scanAuthored(roots, subdir, day) {
   const out = [];
   for (const r of roots) {
     const dir = join8(r.root, subdir);
-    if (!existsSync10(dir)) continue;
+    if (!existsSync11(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day) continue;
@@ -6346,7 +6334,7 @@ function scanEdited(roots, day) {
   const out = [];
   for (const r of roots) {
     const dir = join8(r.root, "skills");
-    if (!existsSync10(dir)) continue;
+    if (!existsSync11(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day) continue;
@@ -6369,10 +6357,10 @@ function claudemdLineDelta(extraRoots, authorEmail, day) {
   const candidates = [];
   for (const e of extraRoots) {
     const f = resolve3(e, "CLAUDE.md");
-    if (existsSync10(f)) candidates.push(f);
+    if (existsSync11(f)) candidates.push(f);
   }
   const homeClaudeMd = join8(homedir3(), "CLAUDE.md");
-  if (existsSync10(homeClaudeMd)) candidates.push(homeClaudeMd);
+  if (existsSync11(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync2(
@@ -6429,7 +6417,7 @@ var init_file_probe = __esm({
 
 // src/daemon-worker.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync, existsSync as existsSync17, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "node:fs";
+import { closeSync, existsSync as existsSync18, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname11, join as join12 } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -6461,9 +6449,9 @@ function readFromCredentialsFile() {
     join(homedir(), ".claude", ".credentials.json"),
     join(homedir(), ".config", "claude", "credentials.json")
   ];
-  for (const path9 of candidates) {
+  for (const path10 of candidates) {
     try {
-      const blob = readFileSync(path9, "utf8");
+      const blob = readFileSync(path10, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -6759,8 +6747,8 @@ async function refreshAccessToken(entry) {
           break;
         }
       }
-      const { writeFileSync: writeFileSync15 } = await import("node:fs");
-      writeFileSync15(p, JSON.stringify(raw, null, 2), "utf8");
+      const { writeFileSync: writeFileSync16 } = await import("node:fs");
+      writeFileSync16(p, JSON.stringify(raw, null, 2), "utf8");
     } catch {
     }
     return j.access_token;
@@ -6887,6 +6875,286 @@ async function fetchGrokUsage() {
   };
 }
 
+// src/usage/codex.ts
+import {
+  existsSync as existsSync5,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import os9 from "node:os";
+import path9 from "node:path";
+var USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+var REFRESH_URL2 = "https://auth.openai.com/oauth/token";
+var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var FIVE_HOUR_SECONDS = 5 * 60 * 60;
+var SEVEN_DAY_SECONDS = 7 * 24 * 60 * 60;
+var REFRESH_BUFFER_MS2 = 5 * 60 * 1e3;
+var CodexApiError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+function codexHome() {
+  const env = process.env.CODEX_HOME?.trim();
+  if (env) return env;
+  return path9.join(os9.homedir(), ".codex");
+}
+function authPath2() {
+  return path9.join(codexHome(), "auth.json");
+}
+function loadAuth() {
+  const p = authPath2();
+  if (!existsSync5(p)) {
+    throw new CodexApiError(
+      "Codex not logged in. Run `codex` to authenticate.",
+      "no_auth"
+    );
+  }
+  let auth;
+  try {
+    auth = JSON.parse(readFileSync7(p, "utf8"));
+  } catch {
+    throw new CodexApiError(
+      "Codex auth.json is unreadable. Run `codex` to log in again.",
+      "no_auth"
+    );
+  }
+  const access = auth.tokens?.access_token?.trim();
+  if (!access) {
+    if (auth.OPENAI_API_KEY?.trim()) {
+      throw new CodexApiError(
+        "Codex usage is not available for API-key-only auth. Sign in with a ChatGPT account via `codex`.",
+        "api_key_only"
+      );
+    }
+    throw new CodexApiError(
+      "Codex auth has no access token. Run `codex` to log in.",
+      "no_auth"
+    );
+  }
+  return { auth, path: p };
+}
+function accessTokenExpiresAtMs(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    const pad = "=".repeat((4 - parts[1].length % 4) % 4);
+    const json = Buffer.from(parts[1] + pad, "base64url").toString("utf8");
+    const payload = JSON.parse(json);
+    if (typeof payload.exp !== "number" || !Number.isFinite(payload.exp)) {
+      return null;
+    }
+    return payload.exp * 1e3;
+  } catch {
+    return null;
+  }
+}
+function needsRefresh2(accessToken, lastRefresh, nowMs = Date.now()) {
+  const expMs = accessTokenExpiresAtMs(accessToken);
+  if (expMs !== null) {
+    return nowMs >= expMs - REFRESH_BUFFER_MS2;
+  }
+  if (!lastRefresh) return false;
+  const ms = Date.parse(lastRefresh);
+  if (!Number.isFinite(ms)) return false;
+  return nowMs - ms > 8 * 24 * 60 * 60 * 1e3;
+}
+async function refreshAccessToken2(auth, filePath) {
+  const refresh = auth.tokens?.refresh_token?.trim();
+  if (!refresh) return null;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: CLIENT_ID,
+    refresh_token: refresh
+  });
+  let res;
+  try {
+    res = await fetch(REFRESH_URL2, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  try {
+    const j = await res.json();
+    if (typeof j.access_token !== "string" || !j.access_token) return null;
+    const next = {
+      ...auth,
+      tokens: {
+        ...auth.tokens,
+        access_token: j.access_token,
+        refresh_token: j.refresh_token ?? auth.tokens?.refresh_token,
+        id_token: j.id_token ?? auth.tokens?.id_token
+      },
+      last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      writeFileSync3(filePath, `${JSON.stringify(next, null, 2)}
+`, {
+        encoding: "utf8",
+        mode: 384
+      });
+    } catch {
+    }
+    return { accessToken: j.access_token, auth: next };
+  } catch {
+    return null;
+  }
+}
+function authHeaders2(accessToken, accountId) {
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    Accept: "application/json",
+    "User-Agent": "fleetlens"
+  };
+  if (accountId?.trim()) {
+    headers["ChatGPT-Account-Id"] = accountId.trim();
+  }
+  return headers;
+}
+function numberOf2(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+function windowSeconds(raw) {
+  if (!raw) return void 0;
+  const sec = numberOf2(raw.limit_window_seconds);
+  if (sec !== void 0) return sec;
+  const minutes = numberOf2(raw.window_minutes);
+  if (minutes !== void 0) return minutes * 60;
+  return void 0;
+}
+function normalizeWindow2(raw, headerPercent, nowMs) {
+  const used = numberOf2(raw?.used_percent) ?? headerPercent;
+  if (used === void 0) return null;
+  let resetsAt = null;
+  const resetUnix = numberOf2(raw?.reset_at) ?? numberOf2(raw?.resets_at);
+  if (resetUnix !== void 0) {
+    resetsAt = new Date(resetUnix * 1e3).toISOString();
+  } else {
+    const after = numberOf2(raw?.reset_after_seconds);
+    if (after !== void 0) {
+      resetsAt = new Date(nowMs + after * 1e3).toISOString();
+    }
+  }
+  return {
+    utilization: Math.min(100, Math.max(0, used)),
+    resets_at: resetsAt
+  };
+}
+function parseCodexWhamUsage(body, headers = {}, nowMs = Date.now()) {
+  if (!body || typeof body !== "object") {
+    throw new CodexApiError("Codex usage response missing body", "parse");
+  }
+  const b = body;
+  const rateLimit = b.rate_limit && typeof b.rate_limit === "object" ? b.rate_limit : {};
+  const headerPrimary = numberOf2(headers["x-codex-primary-used-percent"]);
+  const headerSecondary = numberOf2(headers["x-codex-secondary-used-percent"]);
+  const primary = rateLimit.primary_window && typeof rateLimit.primary_window === "object" ? rateLimit.primary_window : null;
+  const secondary = rateLimit.secondary_window && typeof rateLimit.secondary_window === "object" ? rateLimit.secondary_window : null;
+  const candidates = [
+    { raw: primary, headerPercent: headerPrimary, fallback: "five_hour" },
+    { raw: secondary, headerPercent: headerSecondary, fallback: "seven_day" }
+  ];
+  let fiveHour = null;
+  let sevenDay = null;
+  for (const c of candidates) {
+    const secs = windowSeconds(c.raw);
+    const window = normalizeWindow2(c.raw, c.headerPercent, nowMs);
+    if (!window) continue;
+    if (secs === FIVE_HOUR_SECONDS) fiveHour = window;
+    else if (secs === SEVEN_DAY_SECONDS) sevenDay = window;
+  }
+  if (!fiveHour || !sevenDay) {
+    for (const c of candidates) {
+      const secs = windowSeconds(c.raw);
+      if (secs === FIVE_HOUR_SECONDS || secs === SEVEN_DAY_SECONDS) continue;
+      const window = normalizeWindow2(c.raw, c.headerPercent, nowMs);
+      if (!window) continue;
+      if (c.fallback === "five_hour" && !fiveHour) fiveHour = window;
+      else if (c.fallback === "seven_day" && !sevenDay) sevenDay = window;
+    }
+  }
+  const planRaw = b.plan_type;
+  const planType = typeof planRaw === "string" && planRaw.trim() ? planRaw.trim() : null;
+  return {
+    five_hour: fiveHour ?? { utilization: null, resets_at: null },
+    seven_day: sevenDay ?? { utilization: null, resets_at: null },
+    plan_type: planType
+  };
+}
+async function fetchUsageResponse(accessToken, accountId) {
+  let res;
+  try {
+    res = await fetch(USAGE_URL, {
+      headers: authHeaders2(accessToken, accountId)
+    });
+  } catch (err) {
+    throw new CodexApiError(
+      `Network error reaching Codex usage: ${err.message}`,
+      "network"
+    );
+  }
+  const headers = {};
+  res.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  return { status: res.status, body, headers };
+}
+async function fetchCodexUsage() {
+  const loaded = loadAuth();
+  let auth = loaded.auth;
+  let access = auth.tokens.access_token.trim();
+  const accountId = auth.tokens?.account_id;
+  if (needsRefresh2(access, auth.last_refresh)) {
+    const refreshed = await refreshAccessToken2(auth, loaded.path);
+    if (refreshed) {
+      access = refreshed.accessToken;
+      auth = refreshed.auth;
+    }
+  }
+  let { status, body, headers } = await fetchUsageResponse(access, accountId);
+  if (status === 401 || status === 403) {
+    const refreshed = await refreshAccessToken2(auth, loaded.path);
+    if (refreshed) {
+      access = refreshed.accessToken;
+      ({ status, body, headers } = await fetchUsageResponse(access, accountId));
+    }
+  }
+  if (status < 200 || status >= 300) {
+    throw new CodexApiError(
+      `Codex usage returned HTTP ${status}`,
+      status === 401 || status === 403 ? "no_auth" : "http"
+    );
+  }
+  const windows = parseCodexWhamUsage(body, headers);
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    agent: "codex",
+    five_hour: windows.five_hour,
+    seven_day: windows.seven_day,
+    seven_day_opus: null,
+    seven_day_sonnet: null,
+    seven_day_oauth_apps: null,
+    seven_day_cowork: null,
+    extra_usage: null,
+    plan_type: windows.plan_type
+  };
+}
+
 // src/daemon-worker.ts
 init_storage();
 init_fs();
@@ -6928,7 +7196,7 @@ import { randomUUID } from "node:crypto";
 
 // ../entries/dist/fs.js
 init_fs();
-import { readFileSync as readFileSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, renameSync as renameSync3, existsSync as existsSync7 } from "node:fs";
+import { readFileSync as readFileSync10, readdirSync as readdirSync2, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, renameSync as renameSync3, existsSync as existsSync8 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join as join5 } from "node:path";
 
@@ -7003,12 +7271,12 @@ var PROMPT_FRAME_ORIGIN = {
 
 // ../entries/dist/digest-fs.js
 init_fs();
-import { readFileSync as readFileSync8, readdirSync, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "node:fs";
+import { readFileSync as readFileSync9, readdirSync, writeFileSync as writeFileSync5, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "node:fs";
 import { dirname as dirname3, join as join4 } from "node:path";
 var digestsDirCached = null;
-function parseDigestFile(path9, expectedVersion) {
+function parseDigestFile(path10, expectedVersion) {
   try {
-    const parsed = JSON.parse(readFileSync8(path9, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path10, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -7037,7 +7305,7 @@ function writeDayDigest(digest) {
   const final = dayDigestPath(digest.key);
   mkdirSync4(dirname3(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(digest, null, 2), "utf8");
+  writeFileSync5(tmp, JSON.stringify(digest, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -7048,7 +7316,7 @@ function writeDayDigest(digest) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -7070,7 +7338,7 @@ function writeWeekDigest(digest) {
   const final = weekDigestPath(digest.key);
   mkdirSync4(dirname3(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(digest, null, 2), "utf8");
+  writeFileSync5(tmp, JSON.stringify(digest, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -7081,7 +7349,7 @@ function writeWeekDigest(digest) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
@@ -7122,7 +7390,7 @@ function writeEntry(entry) {
   const final = pathFor(entry.session_id, entry.local_day);
   const tmp = tmpPathFor(final);
   const json = JSON.stringify(entry, null, 2);
-  writeFileSync5(tmp, json, { encoding: "utf8" });
+  writeFileSync6(tmp, json, { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 var PRESERVABLE_STATUSES = /* @__PURE__ */ new Set([
@@ -7154,22 +7422,22 @@ function writeEntryPreservingEnrichment(fresh) {
     toWrite = { ...fresh, enrichment: existing.enrichment };
   }
   const tmp = tmpPathFor(final);
-  writeFileSync5(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
+  writeFileSync6(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 function readEntry(sessionId, localDay2) {
   const p = pathFor(sessionId, localDay2);
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return null;
-  const raw = readFileSync9(p, "utf8");
+  const raw = readFileSync10(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync7(pathFor(sessionId, localDay2));
+  return existsSync8(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -7188,7 +7456,7 @@ function listEntriesForDay(localDay2) {
 
 // src/perception/build-entries.ts
 init_dist();
-import { statSync as statSync2, readFileSync as readFileSync10 } from "node:fs";
+import { statSync as statSync2, readFileSync as readFileSync11 } from "node:fs";
 import { basename as basename2, dirname as dirname4 } from "node:path";
 
 // ../entries/dist/signals.js
@@ -7928,7 +8196,7 @@ function decodeProjectDirName(projectDir) {
 }
 function buildEntriesForFile(filePath) {
   const stat = statSync2(filePath);
-  const raw = readFileSync10(filePath, "utf8");
+  const raw = readFileSync11(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -8189,7 +8457,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "0.16.3",
+    cliVersion: "0.16.6",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -8216,7 +8484,7 @@ async function pushToTeamServer(config, payload) {
 }
 
 // src/team/git-remote.ts
-import { existsSync as existsSync8, readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
 import { dirname as dirname5, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "node:path";
 var GITHUB_URL_RE = /github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
 function parseGithubRemote(url) {
@@ -8242,12 +8510,12 @@ function gitConfigPathFor(dir) {
   const st = statSync3(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
   if (st.isDirectory()) return join6(dotGit, "config");
-  const m = readFileSync11(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  const m = readFileSync12(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
   const gd = isAbsolute2(m[1]) ? m[1] : resolve2(dir, m[1]);
   const commondirFile = join6(gd, "commondir");
-  if (existsSync8(commondirFile)) {
-    const common = readFileSync11(commondirFile, "utf8").trim();
+  if (existsSync9(commondirFile)) {
+    const common = readFileSync12(commondirFile, "utf8").trim();
     return join6(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
   return join6(gd, "config");
@@ -8262,8 +8530,8 @@ function createRepoResolver() {
     try {
       for (let d = dir; ; d = dirname5(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync8(config)) {
-          const url = originUrl2(readFileSync11(config, "utf8"));
+        if (config && existsSync9(config)) {
+          const url = originUrl2(readFileSync12(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
@@ -8279,7 +8547,7 @@ function createRepoResolver() {
 
 // src/team/queue.ts
 init_fs();
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync6 } from "node:fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname as dirname6 } from "node:path";
 var QUEUE_PATH = cclensPath("ingest-queue.jsonl");
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
@@ -8299,7 +8567,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync12(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync13(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -8314,18 +8582,18 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
     } catch {
     }
   }
-  writeFileSync6(queuePath, "", "utf8");
+  writeFileSync7(queuePath, "", "utf8");
   return valid.map((e) => e.payload);
 }
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync12(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync13(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
   const keep = lines.slice(Math.floor(lines.length / 2));
-  writeFileSync6(queuePath, keep.join("\n") + "\n", "utf8");
+  writeFileSync7(queuePath, keep.join("\n") + "\n", "utf8");
 }
 
 // src/team/backfill.ts
@@ -8333,7 +8601,7 @@ init_storage();
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/usage/profile.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 var PROFILE_ENDPOINT = "https://api.anthropic.com/api/oauth/profile";
 var BETA_HEADER2 = "oauth-2025-04-20";
@@ -8377,9 +8645,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync9(cachePath)) return null;
+  if (!existsSync10(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync13(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync14(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -8388,7 +8656,7 @@ function readCachedProfile(cachePath) {
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
   mkdirSync7(dirname7(cachePath), { recursive: true });
-  writeFileSync7(
+  writeFileSync8(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
     { mode: 384 }
@@ -8548,13 +8816,13 @@ async function runTeamBackfill(log3 = noopLog, filePath = USAGE_LOG, configOverr
 
 // src/team/sync-log.ts
 init_fs();
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 var MAX_LINES = 300;
 var MAX_MSG_CHARS = 1900;
 function readPendingSyncLog(watermark) {
   let raw;
   try {
-    raw = readFileSync14(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync15(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -8574,13 +8842,13 @@ function readPendingSyncLog(watermark) {
 
 // src/team/last-push.ts
 init_fs();
-import { writeFileSync as writeFileSync8, unlinkSync as unlinkSync2, mkdirSync as mkdirSync8 } from "node:fs";
+import { writeFileSync as writeFileSync9, unlinkSync as unlinkSync2, mkdirSync as mkdirSync8 } from "node:fs";
 import { join as join7 } from "node:path";
 var LAST_PUSH_FILE = "team-last-push.json";
 function write(record, dir) {
   const d = dir ?? cclensHome();
   mkdirSync8(d, { recursive: true });
-  writeFileSync8(join7(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
+  writeFileSync9(join7(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
 }
 function writeLastPushSuccess(payload, dir) {
   write({ pushedAt: (/* @__PURE__ */ new Date()).toISOString(), ok: true, payload }, dir);
@@ -9180,7 +9448,7 @@ init_fs();
 
 // src/perception/state.ts
 init_fs();
-import { existsSync as existsSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, renameSync as renameSync4 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, renameSync as renameSync4 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 var STALE_MS = 15 * 60 * 1e3;
 var pathCached = null;
@@ -9191,7 +9459,7 @@ function statePath() {
 }
 function readState() {
   const p = statePath();
-  if (!existsSync11(p)) {
+  if (!existsSync12(p)) {
     return {
       sweep_in_progress: false,
       last_sweep_started_at: null,
@@ -9199,14 +9467,14 @@ function readState() {
       file_checkpoints: {}
     };
   }
-  const raw = readFileSync15(p, "utf8");
+  const raw = readFileSync16(p, "utf8");
   return JSON.parse(raw);
 }
 function writeState(s) {
   const p = statePath();
   mkdirSync9(dirname9(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  writeFileSync9(tmp, JSON.stringify(s, null, 2), "utf8");
+  writeFileSync10(tmp, JSON.stringify(s, null, 2), "utf8");
   renameSync4(tmp, p);
 }
 function markSweepStart() {
@@ -9807,8 +10075,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data, path: path10, errorMaps, issueData } = params;
+  const fullPath = [...path10, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -9924,11 +10192,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path10, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path10;
     this._key = key;
   }
   get path() {
@@ -13462,12 +13730,12 @@ var ENRICHMENT_SYSTEM_PROMPT = SYSTEM_PROMPT;
 // ../entries/dist/llm-runner.js
 init_fs();
 import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "node:fs";
+import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync12, existsSync as existsSync14 } from "node:fs";
 import { join as join11 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, existsSync as existsSync12, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync16, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, existsSync as existsSync13, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync17, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
 import { join as join10 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -13498,7 +13766,7 @@ function tmuxRunnerAvailable() {
 }
 function runtimeCwd() {
   const dir = join10(homedir5(), ".cclens", "runtime");
-  if (!existsSync12(dir))
+  if (!existsSync13(dir))
     mkdirSync10(dir, { recursive: true });
   return realpathSync2(dir);
 }
@@ -13506,7 +13774,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   const cfgPath = join10(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync16(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync17(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -13521,7 +13789,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   cfg.projects = projects;
   const tmp = `${cfgPath}.cclens-tmp-${process.pid}`;
   try {
-    writeFileSync10(tmp, JSON.stringify(cfg, null, 2));
+    writeFileSync11(tmp, JSON.stringify(cfg, null, 2));
     renameSync5(tmp, cfgPath);
   } catch {
     try {
@@ -13552,13 +13820,13 @@ async function runClaudeUnderTmuxImpl(args) {
   const systemFile = join10(cwd, `system-${runId}.txt`);
   const userFile = join10(cwd, `user-${runId}.txt`);
   const wrapper = join10(cwd, `run-${runId}.sh`);
-  writeFileSync10(systemFile, args.systemPrompt);
-  writeFileSync10(userFile, args.reminder ? `${args.userPrompt}
+  writeFileSync11(systemFile, args.systemPrompt);
+  writeFileSync11(userFile, args.reminder ? `${args.userPrompt}
 
 ---
 
 ${args.reminder}` : args.userPrompt);
-  writeFileSync10(wrapper, `#!/bin/bash
+  writeFileSync11(wrapper, `#!/bin/bash
 SYS="$(cat ${shellEscape(systemFile)})"
 USR="$(cat ${shellEscape(userFile)})"
 exec ${shellEscape(claudeBin)} \\
@@ -13655,10 +13923,10 @@ function snapshotAllTranscripts() {
   }
   return out;
 }
-function readJsonlCwd(path9, maxLines = 8) {
+function readJsonlCwd(path10, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync16(path9, "utf8");
+    raw = readFileSync17(path10, "utf8");
   } catch {
     return void 0;
   }
@@ -13712,10 +13980,10 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
   }
   throw new TmuxRunError(`timeout waiting for claude to create the session transcript (cwd: ${targetCwd})`);
 }
-function parseTranscript2(path9, defaultModel) {
+function parseTranscript2(path10, defaultModel) {
   let raw;
   try {
-    raw = readFileSync16(path9, "utf8");
+    raw = readFileSync17(path10, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -13790,7 +14058,7 @@ function shellEscape(s) {
 // ../entries/dist/llm-runner.js
 var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync13(RUNS_DIR)) {
+  if (!existsSync14(RUNS_DIR)) {
     try {
       mkdirSync11(RUNS_DIR, { recursive: true });
     } catch {
@@ -13821,15 +14089,15 @@ function newRunId(kind) {
 function tracePath(runId) {
   return join11(RUNS_DIR, `${runId}.jsonl`);
 }
-function safeAppend(path9, line) {
+function safeAppend(path10, line) {
   try {
-    appendFileSync5(path9, line);
+    appendFileSync5(path10, line);
   } catch {
   }
 }
-function safeWrite(path9, line) {
+function safeWrite(path10, line) {
   try {
-    writeFileSync11(path9, line);
+    writeFileSync12(path10, line);
   } catch {
   }
 }
@@ -14218,7 +14486,7 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 
 // ../entries/dist/budget.js
 init_fs();
-import { appendFileSync as appendFileSync6, readFileSync as readFileSync17, existsSync as existsSync14, mkdirSync as mkdirSync12 } from "node:fs";
+import { appendFileSync as appendFileSync6, readFileSync as readFileSync18, existsSync as existsSync15, mkdirSync as mkdirSync12 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 var spendPathCached = null;
 function spendPath() {
@@ -14234,12 +14502,12 @@ function appendSpend(record) {
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync14(p))
+  if (!existsSync15(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync17(p, "utf8");
+  const raw = readFileSync18(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -14261,7 +14529,7 @@ function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
 
 // ../entries/dist/pipeline-lock.js
 init_fs();
-import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync15, readFileSync as readFileSync18, statSync as statSync7 } from "node:fs";
+import { writeFileSync as writeFileSync13, unlinkSync as unlinkSync4, existsSync as existsSync16, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
 var STALE_MS2 = 60 * 1e3;
 var HEARTBEAT_MS = 30 * 1e3;
 var lockPathCached = null;
@@ -14273,7 +14541,7 @@ function lockPath() {
   return lockPathCached;
 }
 function touchLock() {
-  writeFileSync12(lockPath(), String(process.pid), "utf8");
+  writeFileSync13(lockPath(), String(process.pid), "utf8");
 }
 function writeInteractiveLock() {
   touchLock();
@@ -14307,13 +14575,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync15(p))
+  if (!existsSync16(p))
     return false;
   try {
     const mtime = statSync7(p).mtimeMs;
     if (nowMs - mtime > STALE_MS2)
       return false;
-    const pid = Number(readFileSync18(p, "utf8").trim());
+    const pid = Number(readFileSync19(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -14328,7 +14596,7 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync16 } from "node:fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync17 } from "node:fs";
 init_fs();
 var DEFAULT_SETTINGS = {
   ai_features: {
@@ -14360,10 +14628,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync16(p))
+  if (!existsSync17(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync19(p, "utf8");
+    const raw = readFileSync20(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -17123,14 +17391,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.16.3",
+    current: "0.16.6",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.16.3",
+    current: "0.16.6",
     latest,
-    updateAvailable: shouldUpdate("0.16.3", latest)
+    updateAvailable: shouldUpdate("0.16.6", latest)
   };
 }
 
@@ -17178,14 +17446,14 @@ var perceptionHandle = setInterval(async () => {
 }, PERCEPTION_INTERVAL_MS);
 function readUpdateState() {
   try {
-    return JSON.parse(readFileSync20(UPDATE_STATE, "utf8"));
+    return JSON.parse(readFileSync21(UPDATE_STATE, "utf8"));
   } catch {
     return null;
   }
 }
 function writeUpdateState(state) {
   try {
-    writeFileSync14(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
+    writeFileSync15(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
   } catch {
   }
 }
@@ -17230,7 +17498,7 @@ async function runDaemonUpdateCheck() {
       return;
     }
     const entry = cliEntryPath();
-    if (!existsSync17(entry)) {
+    if (!existsSync18(entry)) {
       log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
       return;
     }
@@ -17309,6 +17577,19 @@ async function tick() {
       log2("warn", `zai poll failed: ${err.message}`);
     }
   }
+  try {
+    const codexSnapshot = await fetchCodexUsage();
+    appendSnapshot(USAGE_LOG3, codexSnapshot);
+    const fiveHour = codexSnapshot.five_hour.utilization === null ? "\u2014" : `${codexSnapshot.five_hour.utilization}%`;
+    const sevenDay = codexSnapshot.seven_day.utilization === null ? "\u2014" : `${codexSnapshot.seven_day.utilization}%`;
+    log2("info", `codex snapshot 5h=${fiveHour} 7d=${sevenDay}`);
+  } catch (err) {
+    if (err instanceof CodexApiError && (err.code === "no_auth" || err.code === "api_key_only")) {
+      pruneAgent(USAGE_LOG3, "codex");
+    } else {
+      log2("warn", `codex poll failed: ${err.message}`);
+    }
+  }
   try {
     const grokSnapshot = await fetchGrokUsage();
     appendSnapshot(USAGE_LOG3, grokSnapshot);