fleetlens 0.10.2 → 0.10.3

package/dist/daemon-worker.js

@@ -8,6 +8,40 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/usage/storage.ts
+import { appendFileSync, mkdirSync, readFileSync as readFileSync2, existsSync } from "node:fs";
+import { dirname } from "node:path";
+function appendSnapshot(filePath, snapshot) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  appendFileSync(filePath, JSON.stringify(snapshot) + "\n", "utf8");
+}
+function readSnapshots(filePath) {
+  if (!existsSync(filePath)) return [];
+  const content = readFileSync2(filePath, "utf8");
+  const snapshots = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      snapshots.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return snapshots;
+}
+function latestClaudeCodeSnapshot(filePath) {
+  const all = readSnapshots(filePath);
+  for (let i = all.length - 1; i >= 0; i--) {
+    const s = all[i];
+    if (!s.agent || s.agent === "claude-code") return s;
+  }
+  return null;
+}
+var init_storage = __esm({
+  "src/usage/storage.ts"() {
+    "use strict";
+  }
+});
+
 // ../parser/dist/analytics.js
 function toLocalDay(ms) {
   const d = new Date(ms);
@@ -3742,8 +3776,10 @@ var init_dist = __esm({
 });
 
 // src/daemon-worker.ts
-import { appendFileSync as appendFileSync5, mkdirSync as mkdirSync12 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { appendFileSync as appendFileSync5, closeSync, existsSync as existsSync11, mkdirSync as mkdirSync12, openSync, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname8, join as join8 } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // src/usage/token.ts
 import { execFileSync } from "node:child_process";
@@ -3883,36 +3919,8 @@ function normalizeExtra(raw) {
   };
 }
 
-// src/usage/storage.ts
-import { appendFileSync, mkdirSync, readFileSync as readFileSync2, existsSync } from "node:fs";
-import { dirname } from "node:path";
-function appendSnapshot(filePath, snapshot) {
-  mkdirSync(dirname(filePath), { recursive: true });
-  appendFileSync(filePath, JSON.stringify(snapshot) + "\n", "utf8");
-}
-function readSnapshots(filePath) {
-  if (!existsSync(filePath)) return [];
-  const content = readFileSync2(filePath, "utf8");
-  const snapshots = [];
-  for (const line of content.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      snapshots.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return snapshots;
-}
-function latestClaudeCodeSnapshot(filePath) {
-  const all = readSnapshots(filePath);
-  for (let i = all.length - 1; i >= 0; i--) {
-    const s = all[i];
-    if (!s.agent || s.agent === "claude-code") return s;
-  }
-  return null;
-}
-
 // src/daemon-worker.ts
+init_storage();
 init_fs();
 
 // src/usage/backoff.ts
@@ -3945,8 +3953,10 @@ function writeTeamConfig(config, dir) {
 
 // src/team/push.ts
 init_dist();
+init_storage();
 import { randomUUID } from "node:crypto";
 var SNAPSHOT_FRESHNESS_MS = 10 * 60 * 1e3;
+var POST_TIMEOUT_MS = 15e3;
 function readLatestUsageSnapshotForWire(filePath, nowMs = Date.now()) {
   const raw = latestClaudeCodeSnapshot(filePath);
   if (!raw) return null;
@@ -4005,6 +4015,7 @@ function buildIngestPayload(rollup, usageSnapshot, planTier, cyclePeaks) {
 async function pushToTeamServer(config, payload) {
   const res = await fetch(`${config.serverUrl}/api/ingest/metrics`, {
     method: "POST",
+    signal: AbortSignal.timeout(POST_TIMEOUT_MS),
     headers: {
       "Content-Type": "application/json",
       Authorization: `Bearer ${config.bearerToken}`
@@ -4066,6 +4077,9 @@ function pruneOldest(queuePath) {
   writeFileSync2(queuePath, keep.join("\n") + "\n", "utf8");
 }
 
+// src/team/backfill.ts
+init_storage();
+
 // src/usage/profile.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
@@ -4141,36 +4155,184 @@ async function getPlanTier(cachePath, nowMs = Date.now(), fetcher = fetchProfile
   return fresh.planTier;
 }
 
-// src/team/sync.ts
+// src/team/backfill.ts
 init_fs();
 var USAGE_LOG = cclensPath("usage.jsonl");
 var PROFILE_CACHE = cclensPath("profile.json");
+var BATCH_SIZE = 500;
+var POST_TIMEOUT_MS2 = 15e3;
 var noopLog = () => {
 };
-async function runTeamSync(log3 = noopLog, configOverride) {
+function rawToWire(raw) {
+  const win = (w) => w ? { utilization: w.utilization, resetsAt: w.resets_at } : null;
+  return {
+    capturedAt: raw.captured_at,
+    fiveHour: { utilization: raw.five_hour.utilization, resetsAt: raw.five_hour.resets_at },
+    sevenDay: { utilization: raw.seven_day.utilization, resetsAt: raw.seven_day.resets_at },
+    sevenDayOpus: win(raw.seven_day_opus),
+    sevenDaySonnet: win(raw.seven_day_sonnet),
+    sevenDayOauthApps: win(raw.seven_day_oauth_apps),
+    sevenDayCowork: win(raw.seven_day_cowork),
+    extraUsage: raw.extra_usage ? {
+      isEnabled: raw.extra_usage.is_enabled,
+      monthlyLimitUsd: raw.extra_usage.monthly_limit,
+      usedCreditsUsd: raw.extra_usage.used_credits,
+      utilization: raw.extra_usage.utilization
+    } : null
+  };
+}
+function chunk(items, size) {
+  if (size <= 0) return [items];
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+async function postBatch(config, snapshots, planTier) {
+  const res = await fetch(`${config.serverUrl}/api/ingest/usage-history`, {
+    method: "POST",
+    signal: AbortSignal.timeout(POST_TIMEOUT_MS2),
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.bearerToken}`
+    },
+    body: JSON.stringify({ snapshots, ...planTier ? { planTier } : {} })
+  });
+  if (!res.ok) {
+    return { inserted: 0, skipped: snapshots.length, status: res.status };
+  }
+  const body = await res.json().catch(() => ({}));
+  return {
+    inserted: body.inserted ?? 0,
+    skipped: body.skipped ?? 0,
+    status: res.status
+  };
+}
+function isAfterSince(snapshot, sinceCapturedAt) {
+  if (!sinceCapturedAt) return true;
+  const sinceMs = Date.parse(sinceCapturedAt);
+  if (Number.isNaN(sinceMs)) return true;
+  const capturedMs = Date.parse(snapshot.captured_at);
+  return !Number.isNaN(capturedMs) && capturedMs > sinceMs;
+}
+function capturedAtMs(snapshot) {
+  const ms = Date.parse(snapshot.captured_at);
+  return Number.isNaN(ms) ? Number.MAX_SAFE_INTEGER : ms;
+}
+function latestCapturedAt(snapshots) {
+  let latest = null;
+  for (const s of snapshots) {
+    const ms = Date.parse(s.capturedAt);
+    if (Number.isNaN(ms)) continue;
+    if (!latest || ms > latest.ms) latest = { at: s.capturedAt, ms };
+  }
+  return latest?.at;
+}
+async function runTeamBackfill(log3 = noopLog, filePath = USAGE_LOG, configOverride, options = {}) {
+  const config = configOverride === void 0 ? readTeamConfig() : configOverride;
+  if (!config) {
+    return { paired: false, sentSnapshots: 0, insertedSnapshots: 0, skippedSnapshots: 0, batches: 0 };
+  }
+  const raw = readSnapshots(filePath);
+  const claudeOnly = raw.filter(
+    (s) => (!s.agent || s.agent === "claude-code") && isAfterSince(s, options.sinceCapturedAt)
+  ).sort((a, b) => capturedAtMs(a) - capturedAtMs(b));
+  if (claudeOnly.length === 0) {
+    log3("info", "team backfill: no usage snapshots to send");
+    return { paired: true, sentSnapshots: 0, insertedSnapshots: 0, skippedSnapshots: 0, batches: 0 };
+  }
+  const wire = claudeOnly.map(rawToWire);
+  const batches = chunk(wire, BATCH_SIZE);
+  const planTier = await getPlanTier(PROFILE_CACHE).catch(() => null) ?? void 0;
+  let inserted = 0;
+  let skipped = 0;
+  let lastSnapshotAt;
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    try {
+      const result = await postBatch(config, batch, planTier);
+      if (result.status >= 400) {
+        log3("warn", `team backfill: batch ${i + 1}/${batches.length} failed (${result.status})`);
+        return {
+          paired: true,
+          sentSnapshots: wire.length,
+          insertedSnapshots: inserted,
+          skippedSnapshots: skipped,
+          batches: i,
+          lastSnapshotAt,
+          error: `HTTP ${result.status}`
+        };
+      }
+      inserted += result.inserted;
+      skipped += result.skipped;
+      lastSnapshotAt = latestCapturedAt(batch) ?? lastSnapshotAt;
+    } catch (err) {
+      log3("warn", `team backfill: batch ${i + 1}/${batches.length} error: ${err.message}`);
+      return {
+        paired: true,
+        sentSnapshots: wire.length,
+        insertedSnapshots: inserted,
+        skippedSnapshots: skipped,
+        batches: i,
+        lastSnapshotAt,
+        error: err.message
+      };
+    }
+  }
+  log3(
+    "info",
+    `team backfill: ${inserted} new, ${skipped} already-known across ${batches.length} batch${batches.length === 1 ? "" : "es"}`
+  );
+  return {
+    paired: true,
+    sentSnapshots: wire.length,
+    insertedSnapshots: inserted,
+    skippedSnapshots: skipped,
+    batches: batches.length,
+    lastSnapshotAt
+  };
+}
+
+// src/team/sync.ts
+init_fs();
+var USAGE_LOG2 = cclensPath("usage.jsonl");
+var PROFILE_CACHE2 = cclensPath("profile.json");
+var noopLog2 = () => {
+};
+async function runTeamSync(log3 = noopLog2, configOverride, options = {}) {
   const config = configOverride === void 0 ? readTeamConfig() : configOverride;
   if (!config) return { paired: false, pushed: 0, queued: 0, queuedDrained: 0 };
   try {
     const { listSessions: listSessions2, loadCalibrationCurve: loadCalibrationCurve2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
     const { toLocalDay: toLocalDay3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
     const today = toLocalDay3(Date.now());
+    let nextConfig = { ...config };
+    const persistConfig = (patch) => {
+      nextConfig = { ...nextConfig, ...patch };
+      writeTeamConfig(nextConfig);
+    };
+    const usageBackfill = await runTeamBackfill(log3, USAGE_LOG2, config, {
+      sinceCapturedAt: options.forceUsageBackfill ? void 0 : config.lastSyncedUsageSnapshotAt
+    });
+    if (usageBackfill.lastSnapshotAt) {
+      persistConfig({ lastSyncedUsageSnapshotAt: usageBackfill.lastSnapshotAt });
+    }
     const sessions = await listSessions2({ limit: 1e4 });
     const rollups = buildRollupsForRange(sessions, config.lastSyncedDay);
-    const usageSnapshot = readLatestUsageSnapshotForWire(USAGE_LOG) ?? void 0;
-    const planTier = await getPlanTier(PROFILE_CACHE).catch(() => null) ?? void 0;
+    const usageSnapshot = readLatestUsageSnapshotForWire(USAGE_LOG2) ?? void 0;
+    const planTier = await getPlanTier(PROFILE_CACHE2).catch(() => null) ?? void 0;
     const cyclePeaks = await buildCyclePeaksForPush(planTier, loadCalibrationCurve2);
     if (rollups.length === 0) {
       const hasLiveData = Boolean(usageSnapshot || planTier || cyclePeaks);
       if (!hasLiveData) {
-        log3("info", "team push: nothing to sync");
-        return { paired: true, pushed: 0, queued: 0, queuedDrained: 0 };
+        if (usageBackfill.sentSnapshots === 0) log3("info", "team push: nothing to sync");
+        return { paired: true, pushed: 0, queued: 0, queuedDrained: 0, usageBackfill };
       }
       const payload = buildIngestPayload(void 0, usageSnapshot, planTier, cyclePeaks);
       const result = await pushToTeamServer(config, payload);
       if (!result.ok) {
         log3("warn", `team push (live-only) failed (${result.status}); queueing`);
         enqueuePayload(payload);
-        return { paired: true, pushed: 0, queued: 1, queuedDrained: 0 };
+        return { paired: true, pushed: 0, queued: 1, queuedDrained: 0, usageBackfill };
       }
       let queuedDrained2 = 0;
       const backlog = dequeuePayloads();
@@ -4183,11 +4345,12 @@ async function runTeamSync(log3 = noopLog, configOverride) {
         queuedDrained2++;
       }
       log3("info", `team push ok: live-only (no new daily activity)` + (queuedDrained2 ? `, ${queuedDrained2} queued retried` : ""));
-      return { paired: true, pushed: 1, queued: 0, queuedDrained: queuedDrained2 };
+      return { paired: true, pushed: 1, queued: 0, queuedDrained: queuedDrained2, usageBackfill };
     }
     let pushed = 0;
     let queued = 0;
     let failedDay;
+    let lastPushedDay;
     for (let i = 0; i < rollups.length; i++) {
       const rollup = rollups[i];
       const isLatest = i === rollups.length - 1;
@@ -4208,9 +4371,13 @@ async function runTeamSync(log3 = noopLog, configOverride) {
         break;
       }
       pushed++;
+      lastPushedDay = rollup.day;
+    }
+    if (failedDay) {
+      if (lastPushedDay) persistConfig({ lastSyncedDay: lastPushedDay });
+    } else {
+      persistConfig({ lastSyncedDay: today });
     }
-    const nextConfig = { ...config, lastSyncedDay: today };
-    if (pushed > 0 || !failedDay) writeTeamConfig(nextConfig);
     let queuedDrained = 0;
     if (!failedDay) {
       const backlog = dequeuePayloads();
@@ -4226,7 +4393,7 @@ async function runTeamSync(log3 = noopLog, configOverride) {
     if (pushed > 0) {
       log3("info", `team push ok: ${pushed} day${pushed === 1 ? "" : "s"} pushed` + (queuedDrained ? `, ${queuedDrained} queued retried` : "") + (queued ? `, ${queued} queued for retry` : ""));
     }
-    return { paired: true, pushed, queued, queuedDrained, failedDay };
+    return { paired: true, pushed, queued, queuedDrained, usageBackfill, failedDay };
   } catch (err) {
     const message = err.message;
     log3("warn", `team push error: ${message}`);
@@ -9671,10 +9838,10 @@ exec ${shellEscape(claudeBin)} \\
   "$USR"
 `, { mode: 493 });
   const existingBefore = snapshotAllTranscripts();
-  const spawn2 = spawnSync(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
-  if (spawn2.status !== 0) {
+  const spawn3 = spawnSync(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
+  if (spawn3.status !== 0) {
     cleanup(cwd, runId, tmuxBin, sessionName);
-    throw new TmuxRunError(`tmux new-session failed: ${spawn2.stderr.trim()}`);
+    throw new TmuxRunError(`tmux new-session failed: ${spawn3.stderr.trim()}`);
   }
   const onAbort = () => {
     try {
@@ -9701,10 +9868,10 @@ exec ${shellEscape(claudeBin)} \\
         }
       }
       if (args.onDelta && assembled.length > lastEmittedLength) {
-        const chunk = assembled.slice(lastEmittedLength);
+        const chunk2 = assembled.slice(lastEmittedLength);
         lastEmittedLength = assembled.length;
         try {
-          args.onDelta(chunk);
+          args.onDelta(chunk2);
         } catch {
         }
       }
@@ -10068,8 +10235,8 @@ ${args.reminder}` : args.userPrompt;
     let buffer = "", inputTokens = 0, outputTokens = 0, modelUsed = args.model, stderr = "";
     const startMs = Date.now();
     let lastReportedKb = -1;
-    proc.stdout.on("data", (chunk) => {
-      for (const line of chunk.toString("utf8").split("\n")) {
+    proc.stdout.on("data", (chunk2) => {
+      for (const line of chunk2.toString("utf8").split("\n")) {
         const t = line.trim();
         if (!t)
           continue;
@@ -13179,11 +13346,59 @@ async function backfillYesterdayDigest(opts = {}) {
   return { fired: true, reason: "ok", key: yesterday };
 }
 
+// src/updater.ts
+var PACKAGE_NAME = "fleetlens";
+var CHECK_TIMEOUT_MS = 3e3;
+function shouldUpdate(local, remote) {
+  const l = local.split(".").map(Number);
+  const r = remote.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((r[i] ?? 0) > (l[i] ?? 0)) return true;
+    if ((r[i] ?? 0) < (l[i] ?? 0)) return false;
+  }
+  return false;
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isDevMode() {
+  const script = process.argv[1] ?? "";
+  return script.includes("packages/cli/") || script.includes("packages\\cli\\");
+}
+async function getUpdateAvailability() {
+  if (isDevMode()) return null;
+  const latest = await fetchLatestVersion();
+  if (latest === null) return {
+    current: "0.10.3",
+    latest: null,
+    updateAvailable: false
+  };
+  return {
+    current: "0.10.3",
+    latest,
+    updateAvailable: shouldUpdate("0.10.3", latest)
+  };
+}
+
 // src/daemon-worker.ts
-var USAGE_LOG2 = cclensPath("usage.jsonl");
+var USAGE_LOG3 = cclensPath("usage.jsonl");
 var DAEMON_LOG = cclensPath("daemon.log");
+var UPDATE_STATE = cclensPath("daemon-update.json");
 var WATCHDOG_INTERVAL_MS = 5 * 1e3;
-mkdirSync12(dirname8(USAGE_LOG2), { recursive: true });
+var AUTO_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+mkdirSync12(dirname8(USAGE_LOG3), { recursive: true });
 function log2(level, message) {
   const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${level.toUpperCase()} ${message}
 `;
@@ -13193,8 +13408,10 @@ function log2(level, message) {
   }
 }
 var nextPollAtMs = 0;
+var nextTeamSyncAtMs = 0;
 var currentIntervalMs = BASE_INTERVAL_MS;
 var waitingForRefresh = false;
+var updateCheckInFlight = false;
 var PERCEPTION_INTERVAL_MS = 5 * 60 * 1e3;
 var perceptionInFlight = false;
 var backfillAttempted = false;
@@ -13221,6 +13438,96 @@ var perceptionHandle = setInterval(async () => {
     perceptionInFlight = false;
   }
 }, PERCEPTION_INTERVAL_MS);
+function readUpdateState() {
+  try {
+    return JSON.parse(readFileSync14(UPDATE_STATE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeUpdateState(state) {
+  try {
+    writeFileSync11(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
+  } catch {
+  }
+}
+function nextUpdateCheckFromState(nowMs) {
+  const lastCheckedAt = readUpdateState()?.lastCheckedAt;
+  if (!lastCheckedAt) return 0;
+  const lastMs = Date.parse(lastCheckedAt);
+  if (Number.isNaN(lastMs)) return 0;
+  return nowMs - lastMs >= AUTO_UPDATE_INTERVAL_MS ? 0 : lastMs + AUTO_UPDATE_INTERVAL_MS;
+}
+var nextUpdateCheckAtMs = nextUpdateCheckFromState(Date.now());
+function cliEntryPath() {
+  return join8(dirname8(fileURLToPath(import.meta.url)), "index.js");
+}
+async function runDaemonUpdateCheck() {
+  if (process.env.FLEETLENS_DAEMON_AUTO_UPDATE === "0") {
+    nextUpdateCheckAtMs = Date.now() + AUTO_UPDATE_INTERVAL_MS;
+    return;
+  }
+  if (updateCheckInFlight) return;
+  updateCheckInFlight = true;
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const availability = await getUpdateAvailability();
+    if (!availability) return;
+    const state = {
+      lastCheckedAt: checkedAt,
+      current: availability.current,
+      latest: availability.latest,
+      updateAvailable: availability.updateAvailable
+    };
+    writeUpdateState(state);
+    if (!availability.latest) {
+      log2("warn", "update check skipped: npm registry unreachable");
+      return;
+    }
+    if (!availability.updateAvailable) {
+      log2("info", `update check ok: ${availability.current} is current`);
+      return;
+    }
+    const entry = cliEntryPath();
+    if (!existsSync11(entry)) {
+      log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
+      return;
+    }
+    let logFd = "ignore";
+    try {
+      logFd = openSync(DAEMON_LOG, "a");
+    } catch {
+    }
+    const child = spawn2(process.execPath, [entry, "update"], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env, FLEETLENS_UPDATE_SOURCE: "daemon" }
+    });
+    if (typeof logFd === "number") {
+      child.on("exit", () => {
+        try {
+          closeSync(logFd);
+        } catch {
+        }
+      });
+    }
+    child.unref();
+    writeUpdateState({
+      ...state,
+      updateSpawnedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    log2(
+      "info",
+      `update check found ${availability.latest}; spawned updater pid=${child.pid ?? "unknown"}`
+    );
+  } catch (err) {
+    writeUpdateState({ lastCheckedAt: checkedAt, error: err.message });
+    log2("warn", `update check failed: ${err.message}`);
+  } finally {
+    updateCheckInFlight = false;
+    nextUpdateCheckAtMs = Date.now() + AUTO_UPDATE_INTERVAL_MS;
+  }
+}
 async function tick() {
   for (const source of agentSources) {
     if (source.kind === "claude-code") continue;
@@ -13236,7 +13543,7 @@ async function tick() {
         seven_day_cowork: null,
         extra_usage: null
       };
-      appendSnapshot(USAGE_LOG2, snapshot);
+      appendSnapshot(USAGE_LOG3, snapshot);
       log2(
         "info",
         `${source.kind} snapshot 5h=${snapshot.five_hour.utilization}% 7d=${snapshot.seven_day.utilization}%`
@@ -13247,7 +13554,7 @@ async function tick() {
   }
   try {
     const snapshot = await fetchUsage();
-    appendSnapshot(USAGE_LOG2, snapshot);
+    appendSnapshot(USAGE_LOG3, snapshot);
     log2(
       "info",
       `claude-code snapshot 5h=${snapshot.five_hour.utilization}% 7d=${snapshot.seven_day.utilization}%`
@@ -13304,7 +13611,14 @@ async function runLoop() {
         const outcome = await tick();
         scheduleAfter(Date.now(), outcome);
       }
+    }
+    const teamNow = Date.now();
+    if (teamNow >= nextTeamSyncAtMs) {
       await runTeamSync(log2);
+      nextTeamSyncAtMs = Date.now() + BASE_INTERVAL_MS;
+    }
+    if (Date.now() >= nextUpdateCheckAtMs) {
+      await runDaemonUpdateCheck();
     }
     await sleep2(WATCHDOG_INTERVAL_MS);
   }