@askexenow/exe-os 0.9.276 → 0.9.277

package/dist/telemetry-upload-JGPZKOAF.js

@@ -0,0 +1,739 @@
+import {
+  supportAdminHeaders
+} from "./chunk-2XZ6X3PJ.js";
+import {
+  getOrchestrationMetrics
+} from "./chunk-FZD2J4CZ.js";
+import "./chunk-JLNXT57O.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-ZDNYW3AR.js";
+import "./chunk-FXU7JOXK.js";
+import {
+  loadLicense,
+  readCachedLicenseToken
+} from "./chunk-WJMFNT4M.js";
+import {
+  loadConfig
+} from "./chunk-LAAB5EOU.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-SIAA4J6H.js";
+
+// src/lib/telemetry-upload.ts
+import { readFileSync } from "fs";
+import os from "os";
+import { join as joinPath } from "path";
+
+// src/lib/telemetry-insights.ts
+var SEVERITY_ORDER = {
+  bug: 0,
+  inefficiency: 1,
+  improvement: 2
+};
+function computeInsights(payload) {
+  const insights = [];
+  const counts = payload.metrics?.counts;
+  if (!counts && !payload.usage && !payload.calibration && !payload.toolUsage) {
+    return insights;
+  }
+  if (counts) {
+    if (counts.eventLoopBlocks > 0) {
+      insights.push({
+        severity: "bug",
+        category: "daemon",
+        title: `Daemon event loop blocked ${counts.eventLoopBlocks} times`,
+        detail: "MCP unresponsive periods \u2014 agents may have lost connection during these blocks",
+        metric: "eventLoopBlocks",
+        value: counts.eventLoopBlocks,
+        threshold: 0
+      });
+    }
+    if (counts.mcpUnreachable > 0) {
+      insights.push({
+        severity: "bug",
+        category: "daemon",
+        title: `MCP server unreachable ${counts.mcpUnreachable} times`,
+        detail: "Agents lost connection to the MCP server \u2014 tasks may have stalled",
+        metric: "mcpUnreachable",
+        value: counts.mcpUnreachable,
+        threshold: 0
+      });
+    }
+    if (counts.shardCircuitOpens > 0) {
+      insights.push({
+        severity: "bug",
+        category: "memory",
+        title: `Shard circuit breaker opened ${counts.shardCircuitOpens} times`,
+        detail: "DB encryption or shard routing issues \u2014 memory operations may have failed",
+        metric: "shardCircuitOpens",
+        value: counts.shardCircuitOpens,
+        threshold: 0
+      });
+    }
+    if (counts.consistencyMismatches > 0) {
+      insights.push({
+        severity: "bug",
+        category: "orchestration",
+        title: `Data consistency mismatches detected (${counts.consistencyMismatches})`,
+        detail: "Task DB vs file state diverged \u2014 possible concurrent write corruption",
+        metric: "consistencyMismatches",
+        value: counts.consistencyMismatches,
+        threshold: 0
+      });
+    }
+    if (counts.dispatchFailed > 0) {
+      insights.push({
+        severity: "bug",
+        category: "orchestration",
+        title: `Task dispatch failed ${counts.dispatchFailed} times`,
+        detail: "Agents not receiving work \u2014 check tmux session health and dispatch routing",
+        metric: "dispatchFailed",
+        value: counts.dispatchFailed,
+        threshold: 0
+      });
+    }
+    if (counts.tmuxCommandTimeouts > 0) {
+      insights.push({
+        severity: "bug",
+        category: "daemon",
+        title: `tmux commands timed out ${counts.tmuxCommandTimeouts} times`,
+        detail: "Session management delays \u2014 agent spawning and communication affected",
+        metric: "tmuxCommandTimeouts",
+        value: counts.tmuxCommandTimeouts,
+        threshold: 0
+      });
+    }
+  }
+  const reviewToApproved = payload.metrics?.reviewToApprovedMs;
+  if (reviewToApproved && reviewToApproved.p95 !== null && reviewToApproved.p95 > 18e5) {
+    const mins = Math.round(reviewToApproved.p95 / 6e4);
+    insights.push({
+      severity: "inefficiency",
+      category: "orchestration",
+      title: `Review bottleneck: p95 review time is ${mins}min`,
+      detail: "Work sitting idle waiting for review \u2014 consider auto-approve for low-risk tasks",
+      metric: "reviewToApprovedMs.p95",
+      value: reviewToApproved.p95,
+      threshold: 18e5
+    });
+  }
+  const createToClaim = payload.metrics?.createToClaimMs;
+  if (createToClaim && createToClaim.p95 !== null && createToClaim.p95 > 3e5) {
+    const mins = Math.round(createToClaim.p95 / 6e4);
+    insights.push({
+      severity: "inefficiency",
+      category: "orchestration",
+      title: `Slow task pickup: p95 claim time is ${mins}min`,
+      detail: "Agents not auto-chaining \u2014 tasks are waiting to be claimed",
+      metric: "createToClaimMs.p95",
+      value: createToClaim.p95,
+      threshold: 3e5
+    });
+  }
+  if (counts && counts.sessionBorns > 0) {
+    const idleKillRatio = counts.sessionIdleKills / counts.sessionBorns;
+    if (idleKillRatio > 0.3) {
+      const pct = Math.round(idleKillRatio * 100);
+      insights.push({
+        severity: "inefficiency",
+        category: "orchestration",
+        title: `${pct}% of sessions idle-killed`,
+        detail: "Spawning agents that don't work \u2014 reduce unnecessary session creation",
+        metric: "sessionIdleKills/sessionBorns",
+        value: idleKillRatio,
+        threshold: 0.3
+      });
+    }
+  }
+  if (payload.calibration?.estimation) {
+    const est = payload.calibration.estimation;
+    if (est.total > 0 && est.avgRatio > 2) {
+      insights.push({
+        severity: "inefficiency",
+        category: "calibration",
+        title: `Chronic underestimation: agents estimate ${est.avgRatio.toFixed(1)}x less than actual`,
+        detail: "Tasks consistently take longer than estimated \u2014 affects scheduling accuracy",
+        metric: "estimation.avgRatio",
+        value: est.avgRatio,
+        threshold: 2
+      });
+    }
+    if (est.total > 0 && est.avgRatio < 0.5) {
+      insights.push({
+        severity: "inefficiency",
+        category: "calibration",
+        title: `Chronic overestimation: agents estimate ${est.avgRatio.toFixed(1)}x more than actual`,
+        detail: "Tasks consistently finish faster than estimated \u2014 capacity being underutilized",
+        metric: "estimation.avgRatio",
+        value: est.avgRatio,
+        threshold: 0.5
+      });
+    }
+  }
+  if (payload.calibration?.assertions) {
+    const a = payload.calibration.assertions;
+    if (a.total > 0) {
+      const accuracy = a.correct / a.total;
+      if (accuracy < 0.6) {
+        const pct = Math.round(accuracy * 100);
+        insights.push({
+          severity: "inefficiency",
+          category: "calibration",
+          title: `Low assertion accuracy (${pct}%)`,
+          detail: "Agents making wrong calls more than 40% of the time \u2014 review calibration data",
+          metric: "assertions.accuracy",
+          value: accuracy,
+          threshold: 0.6
+        });
+      }
+    }
+  }
+  if (payload.calibration?.whyWrong) {
+    const entries = Object.entries(payload.calibration.whyWrong);
+    if (entries.length > 0) {
+      entries.sort(([, a], [, b]) => b - a);
+      const [topCategory, topCount] = entries[0];
+      insights.push({
+        severity: "inefficiency",
+        category: "calibration",
+        title: `Most common failure: ${topCategory} (${topCount} times)`,
+        detail: "Recurring failure pattern \u2014 consider adding targeted behaviors or guardrails",
+        metric: "whyWrong.topCategory",
+        value: topCount,
+        threshold: 0
+      });
+    }
+  }
+  if (payload.usage) {
+    if (payload.usage.dreamCyclesRun24h === 0) {
+      insights.push({
+        severity: "improvement",
+        category: "adoption",
+        title: "No dream cycles in 24h",
+        detail: "Session-end hook may not be firing \u2014 dream cycles consolidate session learnings",
+        metric: "dreamCyclesRun24h",
+        value: 0,
+        threshold: 1
+      });
+    }
+    if (payload.usage.assertionsLogged24h === 0 && payload.usage.tasksCompleted24h > 0) {
+      insights.push({
+        severity: "improvement",
+        category: "adoption",
+        title: "Tasks completed without assertions",
+        detail: "Confidence tracking not adopted \u2014 assertions improve calibration accuracy",
+        metric: "assertionsLogged24h",
+        value: 0,
+        threshold: 1
+      });
+    }
+    if (payload.usage.agentCount > 0) {
+      const avgBehaviors = payload.usage.behaviorCount / payload.usage.agentCount;
+      if (avgBehaviors > 50) {
+        insights.push({
+          severity: "improvement",
+          category: "memory",
+          title: `Behavior bloat (${Math.round(avgBehaviors)} avg behaviors per agent)`,
+          detail: "Too many behaviors per agent \u2014 needs consolidation to reduce context size",
+          metric: "behaviorCount/agentCount",
+          value: avgBehaviors,
+          threshold: 50
+        });
+      }
+    }
+  }
+  if (payload.toolUsage) {
+    for (const [name, usage] of Object.entries(payload.toolUsage)) {
+      if (usage.count > 0) {
+        const errorRate = usage.errors / usage.count;
+        if (errorRate > 0.1) {
+          const pct = Math.round(errorRate * 100);
+          insights.push({
+            severity: "improvement",
+            category: "adoption",
+            title: `Tool ${name} has ${pct}% error rate`,
+            detail: "High tool failure rate \u2014 investigate tool configuration or input patterns",
+            metric: `toolUsage.${name}.errorRate`,
+            value: errorRate,
+            threshold: 0.1
+          });
+        }
+      }
+    }
+  }
+  if (counts) {
+    if (counts.contextPressure > 5) {
+      insights.push({
+        severity: "improvement",
+        category: "adoption",
+        title: `High context pressure (${counts.contextPressure} events)`,
+        detail: "Agents hitting context limits frequently \u2014 consider shorter sessions or better memory pruning",
+        metric: "contextPressure",
+        value: counts.contextPressure,
+        threshold: 5
+      });
+    }
+    if (counts.missedReviews > 0) {
+      insights.push({
+        severity: "improvement",
+        category: "orchestration",
+        title: `${counts.missedReviews} missed reviews`,
+        detail: "Review notifications not reaching reviewers \u2014 check review polling configuration",
+        metric: "missedReviews",
+        value: counts.missedReviews,
+        threshold: 0
+      });
+    }
+  }
+  if (payload.investigations) {
+    const inv = payload.investigations;
+    if (inv.avgAttemptsPerBug > 3) {
+      insights.push({
+        severity: "inefficiency",
+        category: "investigation",
+        title: `Agents averaging ${inv.avgAttemptsPerBug.toFixed(1)} attempts per bug`,
+        detail: "High retry count \u2014 investigate reasoning quality and context availability",
+        metric: "investigations.avgAttemptsPerBug",
+        value: inv.avgAttemptsPerBug,
+        threshold: 3
+      });
+    }
+    if (inv.firstAttemptSuccessRate < 0.3 && inv.totalInvestigations >= 3) {
+      const pct = Math.round(inv.firstAttemptSuccessRate * 100);
+      insights.push({
+        severity: "inefficiency",
+        category: "investigation",
+        title: `Only ${pct}% of bugs fixed on first attempt`,
+        detail: "Low first-attempt success \u2014 agents may need better diagnostics before editing",
+        metric: "investigations.firstAttemptSuccessRate",
+        value: inv.firstAttemptSuccessRate,
+        threshold: 0.3
+      });
+    }
+    if (inv.failureCategoryDistribution) {
+      const entries = Object.entries(inv.failureCategoryDistribution);
+      if (entries.length > 0) {
+        entries.sort(([, a], [, b]) => b - a);
+        const [topCategory, topCount] = entries[0];
+        if (topCategory === "lack_of_tools" && topCount >= 2) {
+          insights.push({
+            severity: "improvement",
+            category: "investigation",
+            title: `"lack_of_tools" is dominant failure category (${topCount} times)`,
+            detail: "Agents lack verification tools \u2014 ensure playwright/curl available",
+            metric: "investigations.failureCategory.lack_of_tools",
+            value: topCount,
+            threshold: 2
+          });
+        }
+        if (topCategory === "lack_of_context" && topCount >= 2) {
+          insights.push({
+            severity: "improvement",
+            category: "investigation",
+            title: `"lack_of_context" is dominant failure category (${topCount} times)`,
+            detail: "Agents missing context \u2014 check if relevant code is indexed",
+            metric: "investigations.failureCategory.lack_of_context",
+            value: topCount,
+            threshold: 2
+          });
+        }
+      }
+    }
+    if (inv.avgWastedMinutes > 5) {
+      insights.push({
+        severity: "inefficiency",
+        category: "investigation",
+        title: `Average ${inv.avgWastedMinutes.toFixed(1)} minutes wasted per bug on failed attempts`,
+        detail: "Significant time lost on wrong paths \u2014 improve initial diagnosis accuracy",
+        metric: "investigations.avgWastedMinutes",
+        value: inv.avgWastedMinutes,
+        threshold: 5
+      });
+    }
+  }
+  insights.sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
+  return insights;
+}
+
+// src/lib/telemetry-upload.ts
+function isTelemetryEnabled() {
+  if (process.env.EXE_TELEMETRY === "0") {
+    try {
+      const configPath = joinPath(os.homedir(), ".exe-os", "config.json");
+      const cfg = JSON.parse(readFileSync(configPath, "utf-8"));
+      const plan = String(cfg?.license?.plan ?? cfg?.cloud?.plan ?? "free").toLowerCase();
+      if (plan === "free" || plan === "" || plan === "unknown") {
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+  return true;
+}
+async function buildTelemetryPayload(sinceHours = 24) {
+  const sinceIso = new Date(Date.now() - sinceHours * 60 * 60 * 1e3).toISOString();
+  const metrics = sanitizeMetricsForUpload(await getOrchestrationMetrics({ sinceIso }));
+  let version = "unknown";
+  try {
+    const { readFileSync: readFileSync2 } = await import("fs");
+    const { join, dirname } = await import("path");
+    const { fileURLToPath } = await import("url");
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 5; i++) {
+      try {
+        const pkg = JSON.parse(readFileSync2(join(dir, "package.json"), "utf-8"));
+        if (pkg.version) {
+          version = pkg.version;
+          break;
+        }
+      } catch {
+      }
+      dir = dirname(dir);
+    }
+  } catch {
+  }
+  let toolUsage;
+  try {
+    const { getToolUsageSummary } = await import("./tool-telemetry-SWOUWOUD.js");
+    const summary = getToolUsageSummary();
+    if (Object.keys(summary).length > 0) toolUsage = summary;
+  } catch {
+  }
+  let calibration;
+  try {
+    const { DreamingEngine } = await import("./dreaming-LMYCFKQG.js");
+    const engine = new DreamingEngine();
+    const cal = await engine.computeCalibration("*", sinceHours);
+    if (cal.assertions.total > 0 || cal.estimation.total > 0) {
+      calibration = cal;
+    }
+  } catch {
+  }
+  let usage;
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const db = getClient();
+    const since = sinceIso;
+    let memoryCount = 0;
+    try {
+      const r = await db.execute("SELECT COUNT(*) AS cnt FROM memories");
+      memoryCount = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let agentCount = 0;
+    try {
+      const r = await db.execute("SELECT COUNT(DISTINCT agent_id) AS cnt FROM memories");
+      agentCount = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let sessionCount24h = 0;
+    try {
+      const r = await db.execute({
+        sql: "SELECT COUNT(*) AS cnt FROM orchestration_events WHERE event_type = 'session.born' AND ts >= ?",
+        args: [since]
+      });
+      sessionCount24h = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let tasksCreated24h = 0;
+    try {
+      const r = await db.execute({ sql: "SELECT COUNT(*) AS cnt FROM tasks WHERE created_at >= ?", args: [since] });
+      tasksCreated24h = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let tasksCompleted24h = 0;
+    try {
+      const r = await db.execute({
+        sql: "SELECT COUNT(*) AS cnt FROM tasks WHERE status IN ('needs_review', 'closed') AND updated_at >= ?",
+        args: [since]
+      });
+      tasksCompleted24h = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let tasksCancelled24h = 0;
+    try {
+      const r = await db.execute({
+        sql: "SELECT COUNT(*) AS cnt FROM tasks WHERE status = 'cancelled' AND updated_at >= ?",
+        args: [since]
+      });
+      tasksCancelled24h = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let behaviorCount = 0;
+    try {
+      const r = await db.execute("SELECT COUNT(*) AS cnt FROM behaviors WHERE active = 1");
+      behaviorCount = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let dreamCyclesRun24h = 0;
+    try {
+      const r = await db.execute({
+        sql: "SELECT COUNT(*) AS cnt FROM memories WHERE memory_type = 'observation' AND raw_text LIKE '%DREAM CYCLE%' AND timestamp >= ?",
+        args: [since]
+      });
+      dreamCyclesRun24h = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let assertionsLogged24h = 0;
+    try {
+      const r = await db.execute({
+        sql: "SELECT COUNT(*) AS cnt FROM tasks WHERE assertions IS NOT NULL AND updated_at >= ?",
+        args: [since]
+      });
+      assertionsLogged24h = Number(r.rows[0]?.cnt ?? 0);
+    } catch {
+    }
+    let cloudSyncHealthy = false;
+    try {
+      const r = await db.execute(
+        "SELECT value FROM sync_meta WHERE key = 'last_cloud_push_version'"
+      );
+      cloudSyncHealthy = r.rows.length > 0 && !!r.rows[0]?.value;
+    } catch {
+    }
+    usage = {
+      memoryCount,
+      agentCount,
+      sessionCount24h,
+      tasksCreated24h,
+      tasksCompleted24h,
+      tasksCancelled24h,
+      behaviorCount,
+      dreamCyclesRun24h,
+      assertionsLogged24h,
+      cloudSyncHealthy
+    };
+  } catch {
+  }
+  let investigations;
+  try {
+    const { getClient: getInvClient } = await import("./lib/database.js");
+    const invDb = getInvClient();
+    const invCountResult = await invDb.execute({
+      sql: `SELECT COUNT(DISTINCT investigation_key) AS cnt FROM investigation_attempts WHERE timestamp >= ?`,
+      args: [sinceIso]
+    });
+    const totalInvestigations = Number(invCountResult.rows[0]?.cnt ?? 0);
+    if (totalInvestigations > 0) {
+      const avgResult = await invDb.execute({
+        sql: `SELECT AVG(max_attempt) AS avg_attempts FROM (
+                SELECT investigation_key, MAX(attempt_number) AS max_attempt
+                FROM investigation_attempts WHERE timestamp >= ?
+                GROUP BY investigation_key
+              )`,
+        args: [sinceIso]
+      });
+      const avgAttemptsPerBug = Number(avgResult.rows[0]?.avg_attempts ?? 0);
+      const wastedResult = await invDb.execute({
+        sql: `SELECT COALESCE(SUM(duration_ms), 0) AS wasted FROM investigation_attempts
+              WHERE timestamp >= ? AND result != 'pass'`,
+        args: [sinceIso]
+      });
+      const avgWastedMinutes = Number(wastedResult.rows[0]?.wasted ?? 0) / 6e4 / totalInvestigations;
+      const catResult = await invDb.execute({
+        sql: `SELECT failure_category, COUNT(*) AS cnt FROM investigation_attempts
+              WHERE timestamp >= ? AND failure_category IS NOT NULL
+              GROUP BY failure_category`,
+        args: [sinceIso]
+      });
+      const failureCategoryDistribution = {};
+      for (const row of catResult.rows) {
+        failureCategoryDistribution[String(row.failure_category)] = Number(row.cnt);
+      }
+      const firstAttemptResult = await invDb.execute({
+        sql: `SELECT
+                COUNT(DISTINCT CASE WHEN attempt_number = 1 AND result = 'pass' THEN investigation_key END) AS first_pass,
+                COUNT(DISTINCT investigation_key) AS total
+              FROM investigation_attempts WHERE timestamp >= ?`,
+        args: [sinceIso]
+      });
+      const firstPass = Number(firstAttemptResult.rows[0]?.first_pass ?? 0);
+      const totalForRate = Number(firstAttemptResult.rows[0]?.total ?? 1);
+      const firstAttemptSuccessRate = totalForRate > 0 ? firstPass / totalForRate : 0;
+      investigations = {
+        totalInvestigations,
+        avgAttemptsPerBug,
+        avgWastedMinutes,
+        failureCategoryDistribution,
+        firstAttemptSuccessRate
+      };
+    }
+  } catch {
+  }
+  const payload = {
+    version,
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    totalMemGB: Math.round(os.totalmem() / 1024 ** 3),
+    cpuCount: os.cpus().length,
+    uptimeHours: Math.round(os.uptime() / 3600),
+    metrics,
+    toolUsage,
+    calibration,
+    usage,
+    investigations
+  };
+  try {
+    const insights = computeInsights(payload);
+    if (insights.length > 0) payload.insights = insights;
+  } catch {
+  }
+  return payload;
+}
+function sanitizeMetricsForUpload(metrics) {
+  const agentAliases = /* @__PURE__ */ new Map();
+  const reviewerAliases = /* @__PURE__ */ new Map();
+  const alias = (prefix, value, map) => {
+    if (!map.has(value)) map.set(value, `${prefix}_${map.size + 1}`);
+    return map.get(value);
+  };
+  return {
+    ...metrics,
+    resumeStorms: metrics.resumeStorms.map((storm) => ({
+      ...storm,
+      agentId: alias("agent", storm.agentId, agentAliases)
+    })),
+    reviewerBottlenecks: metrics.reviewerBottlenecks.map((bottleneck) => ({
+      ...bottleneck,
+      reviewer: alias("reviewer", bottleneck.reviewer, reviewerAliases)
+    })),
+    reviewerBacklogs: metrics.reviewerBacklogs.map((backlog) => ({
+      ...backlog,
+      reviewer: alias("reviewer", backlog.reviewer, reviewerAliases)
+    }))
+  };
+}
+var OUTBOX_DIR_NAME = "telemetry-outbox";
+var MAX_OUTBOX_FILES = 30;
+async function getOutboxDir() {
+  const { join } = await import("path");
+  const { homedir } = await import("os");
+  const dir = join(homedir(), ".exe-os", OUTBOX_DIR_NAME);
+  const { mkdirSync } = await import("fs");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+async function persistToOutbox(payload) {
+  try {
+    const { join } = await import("path");
+    const { writeFileSync, readdirSync, unlinkSync } = await import("fs");
+    const dir = await getOutboxDir();
+    const file = join(dir, `${Date.now()}.json`);
+    writeFileSync(file, JSON.stringify(payload), "utf-8");
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json")).sort();
+    while (files.length > MAX_OUTBOX_FILES) {
+      try {
+        unlinkSync(join(dir, files.shift()));
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+async function drainOutbox(sendFn) {
+  let sent = 0;
+  try {
+    const { join } = await import("path");
+    const { readFileSync: readFileSync2, readdirSync, unlinkSync } = await import("fs");
+    const dir = await getOutboxDir();
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of files.slice(0, 2)) {
+      try {
+        const payload = JSON.parse(readFileSync2(join(dir, file), "utf-8"));
+        const result = await sendFn(payload);
+        if (result === "sent") {
+          unlinkSync(join(dir, file));
+          sent++;
+          if (files.length > 1) await new Promise((r) => setTimeout(r, 1e4));
+        } else if (result.includes("429") || result.includes("rate")) {
+          break;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return sent;
+}
+var KILLSWITCH_CACHE_FILE = "telemetry-killswitch.json";
+var KILLSWITCH_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+async function isRemoteKillswitchActive() {
+  try {
+    const { join } = await import("path");
+    const { homedir } = await import("os");
+    const { readFileSync: readFileSync2, writeFileSync, existsSync } = await import("fs");
+    const cachePath = join(homedir(), ".exe-os", KILLSWITCH_CACHE_FILE);
+    if (existsSync(cachePath)) {
+      try {
+        const cached = JSON.parse(readFileSync2(cachePath, "utf-8"));
+        if (Date.now() - cached.checkedAt < KILLSWITCH_CACHE_TTL_MS) {
+          return cached.disabled;
+        }
+      } catch {
+      }
+    }
+    const response = await fetch("https://api.askexe.com/v1/support/telemetry/status", {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    const disabled = response.ok ? (await response.json()).disabled === true : false;
+    try {
+      writeFileSync(cachePath, JSON.stringify({ disabled, checkedAt: Date.now() }), "utf-8");
+    } catch {
+    }
+    return disabled;
+  } catch {
+    return false;
+  }
+}
+async function sendTelemetryUpstream(payload) {
+  if (!isTelemetryEnabled()) return "disabled (EXE_TELEMETRY=0)";
+  if (await isRemoteKillswitchActive()) return "disabled (remote killswitch)";
+  const config = await loadConfig();
+  const routerUrl = process.env.API_ROUTER_URL?.replace(/\/+$/, "");
+  const endpoint = config.support?.bugReportEndpoint?.replace(/\/bug-reports\/?$/, "/telemetry") || (routerUrl ? `${routerUrl}/v1/support/telemetry` : "https://api.askexe.com/v1/support/telemetry");
+  const token = config.support?.bugReportToken || process.env.EXE_BUG_REPORT_TOKEN;
+  const licenseKey = loadLicense() || process.env.EXE_LICENSE_KEY || config.cloud?.apiKey;
+  const licenseToken = readCachedLicenseToken();
+  const doSend = async (p) => {
+    const parsed = new URL(endpoint);
+    if (parsed.protocol !== "https:" && !["localhost", "127.0.0.1", "::1"].includes(parsed.hostname)) {
+      return "failed: insecure endpoint rejected";
+    }
+    const response = await fetch(parsed, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...token ? { authorization: `Bearer ${token}` } : {},
+        ...licenseKey ? { "x-exe-license-key": licenseKey } : {},
+        ...licenseToken ? { "x-exe-license-token": licenseToken } : {},
+        ...supportAdminHeaders(config)
+      },
+      body: JSON.stringify(p),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) return `failed: HTTP ${response.status}`;
+    return "sent";
+  };
+  const retried = await drainOutbox(doSend);
+  try {
+    const result = await doSend(payload);
+    return retried > 0 ? `sent (+ ${retried} retried from outbox)` : result;
+  } catch (err) {
+    await persistToOutbox(payload);
+    return `failed (queued to outbox): ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function sendTelemetry(sinceHours = 24) {
+  const payload = await buildTelemetryPayload(sinceHours);
+  const upstream = await sendTelemetryUpstream(payload);
+  return { payload, upstream };
+}
+export {
+  buildTelemetryPayload,
+  isTelemetryEnabled,
+  sanitizeMetricsForUpload,
+  sendTelemetry,
+  sendTelemetryUpstream
+};