@evident-ai/cli 3.3.1-dev.8b3848f → 3.3.1-dev.8e3d9ea

package/dist/index.js

@@ -746,6 +746,35 @@ async function reportClaudeUsage(agentId, authHeader, snapshot) {
     return { ok: false, error: describeBestEffortError(error2) };
   }
 }
+async function reportResourceUsage(agentId, authHeader, usage) {
+  try {
+    const apiUrl = getApiUrlConfig();
+    const response = await fetch(`${apiUrl}/runners/${agentId}/resource-usage`, {
+      method: "POST",
+      headers: { Authorization: authHeader, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        cpu_percent: usage.cpuPercent,
+        cpu_count: usage.cpuCount,
+        memory_total_bytes: usage.memoryTotalBytes,
+        memory_available_bytes: usage.memoryAvailableBytes,
+        disk_total_bytes: usage.diskTotalBytes,
+        disk_free_bytes: usage.diskFreeBytes,
+        opencode_db_bytes: usage.opencodeDbBytes
+      }),
+      signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      const serverMessage = await readErrorMessage(response);
+      return {
+        ok: false,
+        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
+      };
+    }
+    return { ok: true };
+  } catch (error2) {
+    return { ok: false, error: describeBestEffortError(error2) };
+  }
+}
 async function getAgentInfo(agentId, authHeader) {
   const apiUrl = getApiUrlConfig();
   try {
@@ -934,6 +963,7 @@ import { homedir } from "os";
 import { join } from "path";
 var CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var KEYCHAIN_SERVICE = "Claude Code-credentials";
+var CLAUDE_CREDENTIALS_SEGMENTS = [".claude", ".credentials.json"];
 function parseClaudeCliCredentials(raw) {
   let parsed;
   try {
@@ -967,7 +997,7 @@ function readClaudeCliCredentials() {
     }
   }
   try {
-    const raw = readFileSync(join(homedir(), ".claude", ".credentials.json"), "utf-8");
+    const raw = readFileSync(join(homedir(), ...CLAUDE_CREDENTIALS_SEGMENTS), "utf-8");
     return parseClaudeCliCredentials(raw);
   } catch (err) {
     const code = err.code;
@@ -1063,7 +1093,7 @@ async function claudeUsage() {
 
 // src/commands/run.ts
 import { homedir as homedir3 } from "os";
-import { isAbsolute as isAbsolute2, join as join4, parse, resolve as resolvePath } from "path";
+import { isAbsolute as isAbsolute2, join as join5, parse, resolve as resolvePath } from "path";
 import chalk6 from "chalk";
 
 // ../../packages/types/src/agents/index.ts
@@ -2961,6 +2991,21 @@ function writeTunnelReadyMarker(path, agentId) {
   }
 }
 
+// src/lib/reporting-schedule.ts
+function jitteredDelayMs(baseMs, jitterFraction, random = Math.random) {
+  const jitterRangeMs = baseMs * jitterFraction;
+  return baseMs - jitterRangeMs + random() * (2 * jitterRangeMs);
+}
+function firstReportDelayMs(random = Math.random) {
+  return 5e3 + random() * 1e4;
+}
+function reportFailureLogLevel(consecutiveFailures, reescalationTicks) {
+  return consecutiveFailures === 1 || consecutiveFailures % reescalationTicks === 0 ? "warn" : "debug";
+}
+function failureStreakSuffix(consecutiveFailures) {
+  return consecutiveFailures > 1 ? ` (${consecutiveFailures} consecutive failures)` : "";
+}
+
 // src/lib/claude-usage-reporting.ts
 var VALID_MODES = ["auto", "on", "off"];
 function resolveClaudeUsageReportingMode(flagValue, env) {
@@ -2983,18 +3028,175 @@ function resolveClaudeUsageReportingMode(flagValue, env) {
 var BASE_REPORT_DELAY_MS = 10 * 6e4;
 var REPORT_DELAY_JITTER_FRACTION = 0.2;
 function nextReportDelayMs(random = Math.random) {
-  const jitterRangeMs = BASE_REPORT_DELAY_MS * REPORT_DELAY_JITTER_FRACTION;
-  return BASE_REPORT_DELAY_MS - jitterRangeMs + random() * (2 * jitterRangeMs);
+  return jitteredDelayMs(BASE_REPORT_DELAY_MS, REPORT_DELAY_JITTER_FRACTION, random);
 }
-var FIRST_REPORT_DELAY_MS = 5e3 + Math.random() * 1e4;
+var FIRST_REPORT_DELAY_MS = firstReportDelayMs();
 var CLAUDE_USAGE_FAILURE_REESCALATION_TICKS = 6;
 function claudeUsageFailureLogLevel(consecutiveFailures) {
-  return consecutiveFailures === 1 || consecutiveFailures % CLAUDE_USAGE_FAILURE_REESCALATION_TICKS === 0 ? "warn" : "debug";
+  return reportFailureLogLevel(consecutiveFailures, CLAUDE_USAGE_FAILURE_REESCALATION_TICKS);
+}
+
+// src/lib/resource-usage-reporting.ts
+var ENABLED_VALUES = /* @__PURE__ */ new Set(["on", "true", "1"]);
+var DISABLED_VALUES = /* @__PURE__ */ new Set(["off", "false", "0"]);
+function resolveResourceUsageReportingEnabled(flagValue, env) {
+  if (flagValue === false) {
+    return { enabled: false, warnings: [] };
+  }
+  const raw = env.EVIDENT_RESOURCE_USAGE_REPORTING;
+  if (raw === void 0 || raw === "") {
+    return { enabled: true, warnings: [] };
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (DISABLED_VALUES.has(normalized)) {
+    return { enabled: false, warnings: [] };
+  }
+  if (ENABLED_VALUES.has(normalized)) {
+    return { enabled: true, warnings: [] };
+  }
+  return {
+    enabled: true,
+    warnings: [
+      `Ignoring invalid EVIDENT_RESOURCE_USAGE_REPORTING "${raw}": expected on or off; leaving reporting on`
+    ]
+  };
+}
+
+// src/lib/resource-usage.ts
+import { cpus, totalmem, freemem } from "os";
+import { statfsSync as statfsSync2 } from "fs";
+
+// src/lib/ecs-task-metadata.ts
+var ECS_METADATA_TIMEOUT_MS = 2e3;
+function parseEcsTaskLimits(payload) {
+  if (typeof payload !== "object" || payload === null) return null;
+  const limits = payload.Limits;
+  if (typeof limits !== "object" || limits === null) return null;
+  const cpu = limits.CPU;
+  const memory = limits.Memory;
+  if (typeof cpu !== "number" || !Number.isFinite(cpu) || cpu <= 0) return null;
+  if (typeof memory !== "number" || !Number.isFinite(memory) || memory <= 0) return null;
+  return {
+    cpuCount: Math.max(1, Math.round(cpu)),
+    memoryTotalBytes: memory * 1024 * 1024
+  };
+}
+async function readEcsTaskLimits(env) {
+  const uri = env.ECS_CONTAINER_METADATA_URI_V4;
+  if (!uri) {
+    return { limits: null };
+  }
+  const url = `${uri}/task`;
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(ECS_METADATA_TIMEOUT_MS) });
+    if (!response.ok) {
+      return {
+        limits: null,
+        warning: `ECS task metadata fetch (${url}) returned HTTP ${response.status}`
+      };
+    }
+    const payload = await response.json();
+    const limits = parseEcsTaskLimits(payload);
+    if (limits === null) {
+      return {
+        limits: null,
+        warning: `ECS task metadata fetch (${url}) returned an unexpected payload`
+      };
+    }
+    return { limits };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return { limits: null, warning: `ECS task metadata fetch (${url}) failed: ${message}` };
+  }
+}
+
+// src/lib/resource-usage.ts
+function readCpuSample() {
+  let busyMs = 0;
+  let idleMs = 0;
+  for (const cpu of cpus()) {
+    busyMs += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.irq;
+    idleMs += cpu.times.idle;
+  }
+  return { busyMs, idleMs };
+}
+function cpuPercentBetween(previous, current) {
+  const deltaBusy = current.busyMs - previous.busyMs;
+  const deltaIdle = current.idleMs - previous.idleMs;
+  const total = deltaBusy + deltaIdle;
+  if (total === 0) return null;
+  return Math.round((deltaBusy / total * 100 + Number.EPSILON) * 100) / 100;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function round2(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+function readDisk(homeDir) {
+  try {
+    const stats = statfsSync2(homeDir);
+    return {
+      totalBytes: stats.bsize * stats.blocks,
+      freeBytes: stats.bsize * stats.bavail
+    };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return {
+      totalBytes: null,
+      freeBytes: null,
+      warning: `Could not read disk usage for ${homeDir}: ${message}`
+    };
+  }
+}
+function createResourceUsageCollector(homeDir) {
+  let previous = readCpuSample();
+  return async () => {
+    const current = readCpuSample();
+    const hostCpuPercent = cpuPercentBetween(previous, current);
+    const hostCpuCount = cpus().length;
+    previous = current;
+    const disk = readDisk(homeDir);
+    const opencodeDbBytes = statSessionDbBytes(homeDir);
+    const { limits, warning: ecsWarning } = await readEcsTaskLimits(process.env);
+    const warnings = [];
+    if (disk.warning) warnings.push(disk.warning);
+    if (ecsWarning) warnings.push(ecsWarning);
+    let cpuPercent = hostCpuPercent;
+    let cpuCount = hostCpuCount;
+    let memoryTotalBytes = totalmem();
+    let memoryAvailableBytes = freemem();
+    if (limits !== null) {
+      cpuCount = limits.cpuCount;
+      memoryTotalBytes = limits.memoryTotalBytes;
+      memoryAvailableBytes = clamp(
+        limits.memoryTotalBytes - (totalmem() - freemem()),
+        0,
+        limits.memoryTotalBytes
+      );
+      cpuPercent = hostCpuPercent === null ? null : clamp(round2(hostCpuPercent * hostCpuCount / limits.cpuCount), 0, 100);
+    }
+    return {
+      usage: {
+        cpuPercent,
+        cpuCount,
+        memoryTotalBytes,
+        memoryAvailableBytes,
+        diskTotalBytes: disk.totalBytes,
+        diskFreeBytes: disk.freeBytes,
+        opencodeDbBytes
+      },
+      warnings
+    };
+  };
 }
 
 // src/lib/channels/driver.ts
 import { homedir as homedir2 } from "os";
 
+// src/lib/runner-file-sync.ts
+import { join as join4 } from "path";
+
 // src/lib/file-push.ts
 import { randomUUID } from "crypto";
 import { chmod, mkdir, open as open2, realpath, rename, unlink } from "fs/promises";
@@ -3188,17 +3390,20 @@ async function syncPendingRunnerFiles(options) {
   for (const id of options.ackFailures.keys()) {
     if (!pendingIds.has(id)) options.ackFailures.delete(id);
   }
-  if (pending.length === 0) return 0;
+  if (pending.length === 0) return { applied: 0, claudeCredentialApplied: false };
   options.log({
     level: "info",
     message: `Runner file sync: ${pending.length} file(s) queued for this runner`
   });
   let applied = 0;
+  let claudeCredentialApplied = false;
   for (const file of pending) {
     if ((options.ackFailures.get(file.id) ?? 0) >= MAX_ACK_ATTEMPTS) continue;
-    if (await applyOne(options, file)) applied += 1;
+    const outcome = await applyOne(options, file);
+    if (outcome.applied) applied += 1;
+    if (outcome.claudeCredentialApplied) claudeCredentialApplied = true;
   }
-  return applied;
+  return { applied, claudeCredentialApplied };
 }
 async function listPendingFiles(options) {
   let res;
@@ -3259,6 +3464,11 @@ function asPendingFile(entry) {
   if (typeof size !== "number" || !Number.isFinite(size) || size < 0) return null;
   return { id, path, size };
 }
+var NOT_APPLIED = { applied: false, claudeCredentialApplied: false };
+function isClaudeCredentialPath(requestedPath, homeDir) {
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join4(homeDir, requestedPath.slice(2)) : requestedPath;
+  return expanded === join4(homeDir, ...CLAUDE_CREDENTIALS_SEGMENTS);
+}
 async function applyOne(options, file) {
   const label = `${file.id.slice(0, 8)} (${file.path})`;
   if (options.allowedDirectories.length === 0) {
@@ -3267,7 +3477,7 @@ async function applyOne(options, file) {
       message: `Runner file ${label} rejected: file sync is not enabled on this runner (start it with --enable-file-sync-to)`
     });
     await ack(options, file, "rejected", "file_sync_disabled");
-    return false;
+    return NOT_APPLIED;
   }
   if (file.size > MAX_FILE_PUSH_BYTES) {
     options.log({
@@ -3275,12 +3485,12 @@ async function applyOne(options, file) {
       message: `Runner file ${label} rejected: declared ${file.size} bytes, the limit is ${MAX_FILE_PUSH_BYTES}`
     });
     await ack(options, file, "rejected", "file_too_large");
-    return false;
+    return NOT_APPLIED;
   }
   const download = await downloadContent(options, file, label);
   if (!download.ok) {
     if (download.terminal) await ack(options, file, "rejected", download.code);
-    return false;
+    return NOT_APPLIED;
   }
   let outcome;
   try {
@@ -3296,7 +3506,7 @@ async function applyOne(options, file) {
       message: `Runner file ${label} could not be written: ${describe(err)}`
     });
     await ack(options, file, "rejected", "write_failed");
-    return false;
+    return NOT_APPLIED;
   }
   if (!outcome.ok) {
     options.log({
@@ -3304,14 +3514,17 @@ async function applyOne(options, file) {
       message: `Runner file ${label} rejected (${outcome.code}): ${outcome.message}`
     });
     await ack(options, file, "rejected", outcome.code);
-    return false;
+    return NOT_APPLIED;
   }
   options.log({
     level: "info",
     message: `Runner file ${label} applied (${download.content.byteLength} bytes)`
   });
   await ack(options, file, "applied");
-  return true;
+  return {
+    applied: true,
+    claudeCredentialApplied: isClaudeCredentialPath(file.path, options.homeDir)
+  };
 }
 function durableDownloadCode(status2) {
   return status2 === 413 ? "file_too_large" : "write_failed";
@@ -3756,6 +3969,14 @@ var ChannelDriver = class _ChannelDriver {
    * same trick `lastProxiedActivityAt` uses.
    */
   appliedFileCount = 0;
+  /**
+   * Generation counter, NOT a tally (#1656): advances by exactly one per sync
+   * batch that applied the Claude CLI credential file, not by how many
+   * credential files were in that batch. `run.ts` only ever tests inequality
+   * against the value it saw last cycle, so magnitude is meaningless — keep it
+   * that way rather than "fixing" it into a count.
+   */
+  claudeCredentialApplyCount = 0;
   /**
    * The currently-executing `drainPending()` promise, or null when idle. Lets a
    * graceful shutdown (`waitForInFlight`) await an in-progress drain so a turn it
@@ -3848,7 +4069,7 @@ var ChannelDriver = class _ChannelDriver {
     if (this.syncingFiles) return 0;
     this.syncingFiles = true;
     try {
-      const applied = await syncPendingRunnerFiles({
+      const result = await syncPendingRunnerFiles({
         agentId: this.agentId,
         apiUrl: this.apiUrl,
         getAuthHeader: this.getAuthHeader,
@@ -3858,8 +4079,9 @@ var ChannelDriver = class _ChannelDriver {
         ackFailures: this.fileAckFailures,
         log: this.log
       });
-      this.appliedFileCount += applied;
-      return applied;
+      this.appliedFileCount += result.applied;
+      if (result.claudeCredentialApplied) this.claudeCredentialApplyCount += 1;
+      return result.applied;
     } catch (err) {
       this.log({
         level: "error",
@@ -3950,12 +4172,24 @@ var ChannelDriver = class _ChannelDriver {
    * `appliedFiles` is monotonic so a pull that started AND finished between two
    * idle checks still shows up as an advance.
    *
+   * A THIRD signal, `claudeCredentialApplies`, is a separate re-arm trigger
+   * (#1656), not idle accounting: `run.ts` gates re-probing Claude usage
+   * reporting on it advancing, so an unrelated file sync can never disturb a
+   * healthy reporting cadence (#1627) — it never even reaches that trigger, let
+   * alone gets declined by it. Keep this narrower signal OUT of `appliedFiles`,
+   * whose consumer is idle-timeout suppression and must key on ANY file, not
+   * just a Claude credential.
+   *
    * CALLER CONTRACT: sample `inFlight` BEFORE calling `syncPendingFiles()` for
    * the cycle. `syncPendingFiles` sets the flag synchronously, so a caller that
    * samples afterwards reads `true` every single cycle and can never idle out.
    */
   fileSyncActivity() {
-    return { appliedFiles: this.appliedFileCount, inFlight: this.syncingFiles };
+    return {
+      appliedFiles: this.appliedFileCount,
+      inFlight: this.syncingFiles,
+      claudeCredentialApplies: this.claudeCredentialApplyCount
+    };
   }
   /**
    * OpenCode session ids the session-cleanup sweep (issue #190) must NOT delete:
@@ -4815,6 +5049,17 @@ var ChannelDriver = class _ChannelDriver {
           message: `OpenCode session ${bound} for conversation ${conv.id.slice(0, 8)} no longer exists (deleted or DB reset) \u2014 creating a fresh session and rebinding.`,
           conversation_id: conv.id
         });
+        const watcher = this.watchers.get(bound);
+        if (watcher) {
+          for (const [evidentMessageId, inFlight] of [...watcher.inFlight]) {
+            this.recordReleasedOpencodeId(evidentMessageId, bound, inFlight.opencodeMessageId);
+            this.removeInFlight(watcher, evidentMessageId);
+            void this.postSignal(watcher.conv.id, evidentMessageId, "watcher_recovered", {
+              recovery: "session_gone_released"
+            });
+          }
+          this.watchers.delete(bound);
+        }
         this.sessions.delete(conv.id);
         return { sessionId: await this.createAndBindSession(conv.id), created: true };
       }
@@ -7280,7 +7525,7 @@ function resolveFileSyncDirectories(raw, homeDir) {
     if (trimmed === "") {
       throw new Error("--enable-file-sync-to requires a directory path (got an empty value)");
     }
-    const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join4(homeDir, trimmed.slice(2)) : trimmed;
+    const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join5(homeDir, trimmed.slice(2)) : trimmed;
     if (!isAbsolute2(expanded)) {
       throw new Error(`--enable-file-sync-to requires an absolute directory path; got "${entry}"`);
     }
@@ -7487,6 +7732,7 @@ async function driveChannels(state, driver) {
   let unreachableMs = 0;
   let lastSeenProxiedActivityAt = state.lastProxiedActivityAt;
   let lastSeenAppliedFiles = driver.fileSyncActivity().appliedFiles;
+  let lastSeenClaudeApplies = driver.fileSyncActivity().claudeCredentialApplies;
   while (state.running) {
     const cycleStartedAtMs = performance.now();
     let idleThisCycle = false;
@@ -7510,11 +7756,15 @@ async function driveChannels(state, driver) {
       state.messageCount += processed;
       const proxiedActivity = state.lastProxiedActivityAt !== lastSeenProxiedActivityAt;
       lastSeenProxiedActivityAt = state.lastProxiedActivityAt;
-      const appliedFiles = driver.fileSyncActivity().appliedFiles;
+      const fileActivitySnapshot = driver.fileSyncActivity();
+      const appliedFiles = fileActivitySnapshot.appliedFiles;
       const filesApplied = appliedFiles !== lastSeenAppliedFiles;
       const fileActivity = carriedOverFileSync || filesApplied;
       lastSeenAppliedFiles = appliedFiles;
-      if (filesApplied) state.claudeUsageRearm?.();
+      const claudeCredentialApplies = fileActivitySnapshot.claudeCredentialApplies;
+      const claudeCredentialApplied = claudeCredentialApplies !== lastSeenClaudeApplies;
+      lastSeenClaudeApplies = claudeCredentialApplies;
+      if (claudeCredentialApplied) state.claudeUsageRearm?.();
       if (processed > 0 || driver.hasInFlightWatchers() || proxiedActivity || fileActivity) {
         idlePolls = 0;
         idleMs = 0;
@@ -7583,7 +7833,7 @@ async function driveChannels(state, driver) {
 var SESSION_CLEANUP_FIRST_SWEEP_MS = 1e4;
 var SESSION_DB_RECLAIM_MAX_PAGES = 2e3;
 function sessionDbPath() {
-  return join4(homedir3(), ".local", "share", "opencode", "opencode.db");
+  return join5(homedir3(), ".local", "share", "opencode", "opencode.db");
 }
 async function runSweep(state, driver, config) {
   const mode = `age=${config.maxAgeMs ?? "\u2014"} count=${config.maxCount ?? "\u2014"}`;
@@ -7694,9 +7944,6 @@ function scheduleSessionCleanup(state, driver, options) {
   );
   state.sessionCleanupTimers.push(interval, firstSweep);
 }
-function claudeUsageFailureStreakSuffix(consecutiveFailures) {
-  return consecutiveFailures > 1 ? ` (${consecutiveFailures} consecutive failures)` : "";
-}
 function scheduleClaudeUsageReporting(state, options) {
   const { mode, warnings } = resolveClaudeUsageReportingMode(
     options.claudeUsageReporting,
@@ -7724,13 +7971,13 @@ function scheduleClaudeUsageReporting(state, options) {
     phase = "probe-pending";
     state.claudeUsageTimer = setTimeout(() => void tick(true), FIRST_REPORT_DELAY_MS);
   };
-  const scheduleNextTick = (reportedSuccessfully) => {
+  const scheduleNextTick = () => {
     if (rearmRequested) {
       rearmRequested = false;
       armProbe();
       return;
     }
-    phase = reportedSuccessfully ? "steady-pending-healthy" : "steady-pending-retry";
+    phase = "steady-pending";
     state.claudeUsageTimer = setTimeout(() => void tick(false), nextReportDelayMs());
   };
   const rearm = () => {
@@ -7740,9 +7987,7 @@ function scheduleClaudeUsageReporting(state, options) {
         return;
       case "probe-pending":
         return;
-      case "steady-pending-healthy":
-        return;
-      case "steady-pending-retry":
+      case "steady-pending":
         if (state.claudeUsageTimer) {
           clearTimeout(state.claudeUsageTimer);
           state.claudeUsageTimer = null;
@@ -7780,10 +8025,10 @@ function scheduleClaudeUsageReporting(state, options) {
         logActivity(state, {
           type: "info",
           level: claudeUsageFailureLogLevel(consecutiveFailures),
-          message: `Failed to report Claude usage: ${result.error}${claudeUsageFailureStreakSuffix(consecutiveFailures)}`
+          message: `Failed to report Claude usage: ${result.error}${failureStreakSuffix(consecutiveFailures)}`
         });
       }
-      scheduleNextTick(result.ok);
+      scheduleNextTick();
     } catch (error2) {
       if (error2 instanceof ClaudeUsageError && isLocalCredentialProblem(error2)) {
         if (mode === "on") {
@@ -7792,7 +8037,7 @@ function scheduleClaudeUsageReporting(state, options) {
             level: "warn",
             message: "Claude usage reporting is forced on but no usable Claude Code login was found \u2014 run `claude` to sign in; reporting will keep retrying"
           });
-          scheduleNextTick(false);
+          scheduleNextTick();
         } else if (isProbe) {
           logActivity(state, {
             type: "info",
@@ -7807,7 +8052,7 @@ function scheduleClaudeUsageReporting(state, options) {
             level: "debug",
             message: `Claude usage reporting: ${error2.message}`
           });
-          scheduleNextTick(false);
+          scheduleNextTick();
         }
       } else {
         consecutiveFailures++;
@@ -7815,15 +8060,99 @@ function scheduleClaudeUsageReporting(state, options) {
         logActivity(state, {
           type: "info",
           level: claudeUsageFailureLogLevel(consecutiveFailures),
-          message: `Claude usage reporting failed: ${message}${claudeUsageFailureStreakSuffix(consecutiveFailures)}`
+          message: `Claude usage reporting failed: ${message}${failureStreakSuffix(consecutiveFailures)}`
         });
-        scheduleNextTick(false);
+        scheduleNextTick();
       }
     }
   };
   armProbe();
   return rearm;
 }
+var RESOURCE_USAGE_BASE_REPORT_DELAY_MS = 10 * 6e4;
+var RESOURCE_USAGE_REPORT_DELAY_JITTER_FRACTION = 0.2;
+var RESOURCE_USAGE_FAILURE_REESCALATION_TICKS = 6;
+function scheduleResourceUsageReporting(state, options) {
+  const { enabled, warnings } = resolveResourceUsageReportingEnabled(
+    options.resourceUsageReporting,
+    process.env
+  );
+  for (const warning2 of warnings) {
+    logActivity(state, {
+      type: "info",
+      level: "warn",
+      message: `Resource usage reporting: ${warning2}`
+    });
+  }
+  if (!enabled) {
+    logActivity(state, {
+      type: "info",
+      level: "debug",
+      message: "Resource usage reporting is off (--no-resource-usage-reporting)"
+    });
+    return;
+  }
+  const collect = createResourceUsageCollector(homedir3());
+  let consecutiveFailures = 0;
+  const tick = async () => {
+    try {
+      const { usage, warnings: collectWarnings } = await collect();
+      for (const warning2 of collectWarnings) {
+        logActivity(state, {
+          type: "info",
+          level: "debug",
+          message: `Resource usage collection: ${warning2}`
+        });
+      }
+      const result = await reportResourceUsage(state.agentId, state.authHeader, usage);
+      if (result.ok) {
+        if (consecutiveFailures > 0) {
+          logActivity(state, {
+            type: "info",
+            level: "info",
+            message: "Resource usage reporting recovered"
+          });
+        }
+        consecutiveFailures = 0;
+        logActivity(state, {
+          type: "info",
+          level: "debug",
+          message: "Reported resource usage to Evident"
+        });
+      } else {
+        consecutiveFailures++;
+        logActivity(state, {
+          type: "info",
+          level: reportFailureLogLevel(
+            consecutiveFailures,
+            RESOURCE_USAGE_FAILURE_REESCALATION_TICKS
+          ),
+          message: `Failed to report resource usage: ${result.error}${failureStreakSuffix(consecutiveFailures)}`
+        });
+      }
+    } catch (error2) {
+      consecutiveFailures++;
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      logActivity(state, {
+        type: "info",
+        level: reportFailureLogLevel(
+          consecutiveFailures,
+          RESOURCE_USAGE_FAILURE_REESCALATION_TICKS
+        ),
+        message: `Resource usage reporting failed: ${message}${failureStreakSuffix(consecutiveFailures)}`
+      });
+    } finally {
+      state.resourceUsageTimer = setTimeout(
+        () => void tick(),
+        jitteredDelayMs(
+          RESOURCE_USAGE_BASE_REPORT_DELAY_MS,
+          RESOURCE_USAGE_REPORT_DELAY_JITTER_FRACTION
+        )
+      );
+    }
+  };
+  state.resourceUsageTimer = setTimeout(() => void tick(), firstReportDelayMs());
+}
 async function notifyOffline(state) {
   if (!state.agentId || !state.authHeader) return;
   if (!state.connected) {
@@ -7864,6 +8193,10 @@ async function cleanup(state, opts = {}) {
     state.claudeUsageTimer = null;
   }
   state.claudeUsageRearm = null;
+  if (state.resourceUsageTimer) {
+    clearTimeout(state.resourceUsageTimer);
+    state.resourceUsageTimer = null;
+  }
   if (opts.graceful && state.channelDriver) {
     state.channelDriver.stop();
     log2(state, "Draining in-flight channel work before shutdown...");
@@ -7946,6 +8279,7 @@ async function run(options) {
     sessionCleanupTimers: [],
     claudeUsageTimer: null,
     claudeUsageRearm: null,
+    resourceUsageTimer: null,
     authHeader: ""
   };
   setTelemetryAuthProvider(() => ({ authHeader: state.authHeader, agentId: state.agentId }));
@@ -8345,6 +8679,7 @@ async function run(options) {
     }
     scheduleSessionCleanup(state, channelDriver, options);
     state.claudeUsageRearm = scheduleClaudeUsageReporting(state, options);
+    scheduleResourceUsageReporting(state, options);
     if (!interactive || state.json) {
       log2(state, "Driving channel messages...");
     }
@@ -8425,6 +8760,9 @@ program.command("run").description("Connect to Evident and process messages").op
 ).option(
   "--claude-usage-reporting <mode>",
   "Report Claude subscription usage to Evident: auto | on | off (default: auto). Env: EVIDENT_CLAUDE_USAGE_REPORTING"
+).option(
+  "--no-resource-usage-reporting",
+  "Don't report this machine's CPU and memory usage to Evident (reporting is on by default). Env: EVIDENT_RESOURCE_USAGE_REPORTING=off"
 ).option(
   "--enable-file-sync-to <dir>",
   "Allow Evident to write files into this directory (repeatable). Omit to disable file sync entirely.",
@@ -8457,6 +8795,9 @@ program.command("run").description("Connect to Evident and process messages").op
       // Raw string — the resolver in run.ts single-sources parsing
       // (resolveClaudeUsageReportingMode).
       claudeUsageReporting: options.claudeUsageReporting,
+      // Raw value — resolution is single-sourced in run.ts's
+      // resolveResourceUsageReportingEnabled.
+      resourceUsageReporting: options.resourceUsageReporting,
       // Raw values — expansion/validation is single-sourced in run.ts's
       // resolveFileSyncDirectories.
       enableFileSyncTo: options.enableFileSyncTo,