turbollm 1.9.2 → 1.9.4

package/dist/cli.js

@@ -23,9 +23,9 @@ function hideChildConsoleWindows() {
 
 // src/cli.ts
 import { spawn as spawn8 } from "child_process";
-import { openSync as openSync3, readFileSync as readFileSync16 } from "fs";
+import { openSync as openSync3, readFileSync as readFileSync19 } from "fs";
 import { serve } from "@hono/node-server";
-import { dirname as dirname12, join as join33 } from "path";
+import { dirname as dirname12, join as join35 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/config.ts
@@ -33,7 +33,7 @@ import { randomUUID } from "crypto";
 import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 var VRAM_HEADROOM_MIN_MB = 300;
 var VRAM_HEADROOM_MAX_MB = 2048;
 var VRAM_HEADROOM_DEFAULT_MB = 1024;
@@ -188,7 +188,7 @@ var ConfigStore = class _ConfigStore {
     renameSync(tmp, this.filePath);
   }
 };
-function migrate(raw, _from) {
+function migrate(raw, from) {
   const cfg2 = defaultConfig();
   if (typeof raw.host === "string") cfg2.daemon.host = raw.host;
   if (typeof raw.port === "number") cfg2.daemon.port = raw.port;
@@ -215,6 +215,7 @@ function migrate(raw, _from) {
       cfg2[k] = v;
     }
   }
+  if (from < 4 && cfg2.telemetry.level === "off") cfg2.telemetry.level = "unset";
   return cfg2;
 }
 function splitLaunchArgs(args) {
@@ -1404,6 +1405,10 @@ var Manager = class _Manager {
   child = null;
   startedAt = 0;
   errInfo = null;
+  /** Optional observer for load outcomes, wired in cli.ts (ADR-299). Kept as a
+   *  plain callback so Manager has no telemetry dependency and tests need no
+   *  stub. A throwing observer must never break a load. */
+  onLoadSettled;
   lastCommand = null;
   lastActivity = 0;
   logPathStr = "";
@@ -1427,9 +1432,11 @@ var Manager = class _Manager {
         if (hooks?.beforeStart) await hooks.beforeStart();
         await this.startInternal(opts);
         await this.awaitNotStarting();
+        this.reportLoad(this.state === "running", this.errInfo);
       } catch (e) {
         this.state = "error";
         this.errInfo = { code: "load_failed", message: e instanceof Error ? e.message : String(e), exitCode: -1, logTail: [] };
+        this.reportLoad(false, this.errInfo);
         throw e;
       }
     });
@@ -1444,6 +1451,14 @@ var Manager = class _Manager {
       await this.awaitNotStarting();
     });
   }
+  /** Notify the load observer, swallowing anything it throws — an observer is
+   *  by definition not allowed to affect whether a model loaded. */
+  reportLoad(ok, err7) {
+    try {
+      this.onLoadSettled?.(ok, err7);
+    } catch {
+    }
+  }
   /** Wait until the engine leaves the 'starting' state (→ running or error/stopped),
    *  bounded by the engine kind's readiness window plus a small grace. The internal
    *  readiness loop flips the state and surfaces errors; this just keeps the load
@@ -1475,9 +1490,9 @@ var Manager = class _Manager {
       }
     }
     const port2 = await allocPort(opts.preferredPort);
-    const logPath = join10(this.store.dir(), "logs", `engine-${opts.engine.id}.log`);
-    mkdirSync6(dirname2(logPath), { recursive: true });
-    const logStream = createWriteStream2(logPath);
+    const logPath2 = join10(this.store.dir(), "logs", `engine-${opts.engine.id}.log`);
+    mkdirSync6(dirname2(logPath2), { recursive: true });
+    const logStream = createWriteStream2(logPath2);
     logStream.write(
       `[turbollm] starting engine "${opts.engine.name}" on internal port ${port2} (127.0.0.1 only \u2014 the engine's own port, NOT the TurboLLM app/UI port).
 `
@@ -1507,7 +1522,7 @@ var Manager = class _Manager {
     this.startedAt = Date.now();
     this.errInfo = null;
     this.lastActivity = Date.now();
-    this.logPathStr = logPath;
+    this.logPathStr = logPath2;
     this.exited = new Promise((res) => {
       this.resolveExited = res;
     });
@@ -3311,11 +3326,23 @@ var ProvisionState = class {
     this.s.part = part;
     this.s.parts = parts;
   }
+  /** Optional observer for the terminal outcome, wired in cli.ts (ADR-299
+   *  `onboarding_step`). The error string is deliberately not passed — the only
+   *  consumer may never transmit free text. */
+  onSettled;
   done() {
     this.s = { active: false, phase: "idle", backend: "", pct: 0, part: 1, parts: 1, error: null };
+    this.settle(true);
   }
   fail(error) {
     this.s = { active: false, phase: "error", backend: this.s.backend, pct: 0, part: 1, parts: 1, error };
+    this.settle(false);
+  }
+  settle(ok) {
+    try {
+      this.onSettled?.(ok);
+    } catch {
+    }
   }
 };
 
@@ -3345,11 +3372,24 @@ var BuildState = class {
     this.s.log.push(trimmed);
     if (this.s.log.length > LOG_TAIL) this.s.log.splice(0, this.s.log.length - LOG_TAIL);
   }
+  /** Optional observer for the terminal outcome, wired in cli.ts (ADR-299
+   *  `onboarding_step`). A plain callback so this module keeps no telemetry
+   *  dependency; the error STRING is deliberately not passed, because the only
+   *  consumer may never send free text. */
+  onSettled;
   done() {
     this.s = { ...this.s, active: false, phase: "done", error: null };
+    this.settle(true);
   }
   fail(error) {
     this.s = { ...this.s, active: false, phase: "error", error };
+    this.settle(false);
+  }
+  settle(ok) {
+    try {
+      this.onSettled?.(ok);
+    } catch {
+    }
   }
 };
 
@@ -7004,6 +7044,18 @@ var DownloadManager = class {
   provenancePath;
   provenanceList = [];
   nextSeq = 0;
+  /** Optional observer for a download's terminal outcome, wired in cli.ts
+   *  (ADR-299 `onboarding_step`). Separate from `onComplete`, which fires only
+   *  on success and exists to trigger a rescan — reusing it would have made a
+   *  failed download indistinguishable from one that never started. The error
+   *  string is deliberately not passed: the only consumer may never send text. */
+  onSettled;
+  settle(outcome) {
+    try {
+      this.onSettled?.(outcome);
+    } catch {
+    }
+  }
   /** Permanent record of which repo+file each downloaded model came from (spec 10 §3).
    *  Consumed by the repo-detail route to mark a quant "Downloaded" for the exact repo
    *  it was pulled from. */
@@ -7276,6 +7328,7 @@ var DownloadManager = class {
         this.onComplete();
       } catch {
       }
+      this.settle("ok");
     } catch (e) {
       this.controllers.delete(rec.id);
       rec.bytesPerSec = 0;
@@ -7287,6 +7340,7 @@ var DownloadManager = class {
         rec.error = e instanceof Error ? e.message : String(e);
       }
       this.persist();
+      this.settle(rec.status === "cancelled" ? "cancelled" : "fail");
     } finally {
       this.pump();
     }
@@ -7422,9 +7476,8 @@ function repoSubdir(repo) {
 
 // src/bench/bench.ts
 import { execFile as execFile10 } from "child_process";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join19 } from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import { readFileSync as readFileSync9 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/api/path-utils.ts
 function inferRepoFromPath(filePath, modelDirs) {
@@ -7443,6 +7496,353 @@ function inferRepoFromPath(filePath, modelDirs) {
   return null;
 }
 
+// src/telemetry/queue.ts
+import { mkdirSync as mkdirSync10, readdirSync as readdirSync6, readFileSync as readFileSync7, rmSync as rmSync10, writeFileSync as writeFileSync8 } from "fs";
+import { join as join19 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/telemetry/schema.ts
+var TELEMETRY_SCHEMA_VERSION = 1;
+var EVENT_NAMES = [
+  "app_first_run",
+  "daily_active",
+  "onboarding_step",
+  "model_first_load",
+  "feature_first_use",
+  "feature_used_daily",
+  "error",
+  "consent_choice",
+  "bench_result"
+];
+var ENVELOPE_KEYS = ["schema", "event", "ts", "machineId", "app", "hw", "payload", "level"];
+var FEATURES = [
+  "chat",
+  "code",
+  "research",
+  "artifacts",
+  "mcp",
+  "agents",
+  "autotune",
+  "skills",
+  "image"
+];
+var ONBOARDING_STEPS = ["engine_install", "engine_build", "model_download", "first_load"];
+var OUTCOMES = ["ok", "fail", "cancelled"];
+var FAIL_REASONS = [
+  "oom",
+  "no_engine",
+  "bad_gguf",
+  "unsupported_arch",
+  "timeout",
+  "cancelled",
+  "other"
+];
+var COUNT_BUCKETS = ["1", "2-5", "6-20", "21-100", "100+"];
+var ERROR_FINGERPRINTS = [
+  "cuda_oom",
+  "engine_crash",
+  "engine_start_timeout",
+  "model_load_failed",
+  "gateway_unreachable",
+  "download_failed",
+  "build_failed",
+  "other"
+];
+var CONSENT_LEVELS = ["off", "anon", "full"];
+var MAX_IDENT_LEN = 96;
+function isSafeIdent(v) {
+  if (typeof v !== "string" || v.length === 0 || v.length > MAX_IDENT_LEN) return false;
+  if (!/^[A-Za-z0-9 ._:()+\-]+$/.test(v)) return false;
+  if (v.includes("..")) return false;
+  return true;
+}
+function isSafeOs(v) {
+  return typeof v === "string" && /^[a-z0-9]{1,32}\/[a-z0-9]{1,32}$/.test(v);
+}
+var BENCH_PAYLOAD = {
+  model: {
+    name: { kind: "ident" },
+    quant: { kind: "ident" },
+    arch: { kind: "ident" },
+    sizeBytes: { kind: "number" },
+    moe: { kind: "boolean" }
+  },
+  engine: { version: { kind: "ident" } },
+  params: {
+    ctx: { kind: "number" },
+    ngl: { kind: "number" },
+    nglFit: { kind: "boolean", optional: true },
+    nCpuMoe: { kind: "number" },
+    nCpuMoeFit: { kind: "boolean", optional: true },
+    parallel: { kind: "number" },
+    kvTypeK: { kind: "ident" },
+    flashAttn: { kind: "ident" }
+  },
+  result: {
+    tps: { kind: "number" },
+    ttftMs: { kind: "number" },
+    // `null` is real data here: BenchResult.vramMb is `number | null`, meaning
+    // "we could not measure VRAM on this box" — distinct from "not reported".
+    vramMb: { kind: "number", optional: true, nullable: true },
+    outcome: { enum: OUTCOMES }
+  }
+};
+var HW_SPEC = {
+  cpu: { kind: "ident" },
+  ramMb: { kind: "number" }
+};
+var PAYLOAD_SPECS = {
+  onboarding_step: { step: { enum: ONBOARDING_STEPS }, outcome: { enum: OUTCOMES } },
+  model_first_load: { outcome: { enum: OUTCOMES }, failReason: { enum: FAIL_REASONS, optional: true } },
+  feature_first_use: { feature: { enum: FEATURES } },
+  feature_used_daily: { feature: { enum: FEATURES }, countBucket: { enum: COUNT_BUCKETS } },
+  error: { fingerprint: { enum: ERROR_FINGERPRINTS } }
+};
+function checkFields(obj, spec, path) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return `${path} must be an object`;
+  }
+  const o = obj;
+  for (const key of Object.keys(o)) {
+    if (!Object.prototype.hasOwnProperty.call(spec, key)) return `unknown field: ${path}.${key}`;
+  }
+  for (const [key, field] of Object.entries(spec)) {
+    const v = o[key];
+    if (v === void 0) {
+      if (field.optional) continue;
+      return `missing field: ${path}.${key}`;
+    }
+    const where = `${path}.${key}`;
+    if (v === null && !("enum" in field) && field.nullable) continue;
+    if ("enum" in field) {
+      if (typeof v !== "string" || !field.enum.includes(v)) return `invalid value for ${where}: ${String(v)}`;
+    } else if (field.kind === "ident") {
+      if (!isSafeIdent(v)) return `invalid value for ${where}`;
+    } else if (field.kind === "os") {
+      if (!isSafeOs(v)) return `invalid value for ${where}`;
+    } else if (field.kind === "number") {
+      if (typeof v !== "number" || !Number.isFinite(v)) return `invalid value for ${where}: ${String(v)}`;
+    } else if (typeof v !== "boolean") {
+      return `invalid value for ${where}: ${String(v)}`;
+    }
+  }
+  return null;
+}
+function validateHw(hw) {
+  if (typeof hw !== "object" || hw === null || Array.isArray(hw)) return "hw must be an object";
+  const h = hw;
+  const { gpus, ...flat } = h;
+  const flatError = checkFields(flat, HW_SPEC, "hw");
+  if (flatError !== null) return flatError;
+  if (!Array.isArray(gpus)) return "missing field: hw.gpus";
+  for (const g of gpus) {
+    const e = checkFields(g, { name: { kind: "ident" }, vramMb: { kind: "number" } }, "hw.gpus[]");
+    if (e !== null) return e;
+  }
+  return null;
+}
+function validatePayload(eventName, payload) {
+  if (eventName === "bench_result") {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+      return "bench_result requires an object payload";
+    }
+    const p = payload;
+    for (const key of Object.keys(p)) {
+      if (!Object.prototype.hasOwnProperty.call(BENCH_PAYLOAD, key)) return `unknown field: payload.${key}`;
+    }
+    for (const [block, spec2] of Object.entries(BENCH_PAYLOAD)) {
+      const e = checkFields(p[block], spec2, `payload.${block}`);
+      if (e !== null) return e;
+    }
+    return null;
+  }
+  const spec = PAYLOAD_SPECS[eventName];
+  if (spec === void 0) {
+    return payload === void 0 ? null : `${eventName} takes no payload`;
+  }
+  return checkFields(payload, spec, "payload");
+}
+function validateEvent(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ok: false, reason: "event must be an object" };
+  }
+  const e = raw;
+  if (typeof e.event !== "string" || !EVENT_NAMES.includes(e.event)) {
+    return { ok: false, reason: `unknown event name: ${String(e.event)}` };
+  }
+  for (const key of Object.keys(e)) {
+    if (!ENVELOPE_KEYS.includes(key)) {
+      return { ok: false, reason: `unknown field: ${key}` };
+    }
+  }
+  if (e.schema !== TELEMETRY_SCHEMA_VERSION) {
+    return { ok: false, reason: `invalid value for schema: ${String(e.schema)}` };
+  }
+  if (e.event === "consent_choice") {
+    for (const banned of ["machineId", "app", "hw", "ts", "payload"]) {
+      if (banned in e) return { ok: false, reason: `consent_choice must not carry ${banned}` };
+    }
+    if (typeof e.level !== "string" || !CONSENT_LEVELS.includes(e.level)) {
+      return { ok: false, reason: `invalid value for level: ${String(e.level)}` };
+    }
+    return { ok: true, event: e };
+  }
+  if ("level" in e) return { ok: false, reason: "level is only valid on consent_choice" };
+  if (typeof e.ts !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(e.ts)) {
+    return { ok: false, reason: "missing or malformed field: ts" };
+  }
+  if (typeof e.machineId !== "string" || !/^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(e.machineId)) {
+    return { ok: false, reason: "missing or malformed field: machineId" };
+  }
+  const appError = checkFields(e.app, { version: { kind: "ident" }, os: { kind: "os" } }, "app");
+  if (appError !== null) return { ok: false, reason: appError };
+  if (e.event === "bench_result") {
+    const hwError = validateHw(e.hw);
+    if (hwError !== null) return { ok: false, reason: hwError };
+  } else if ("hw" in e) {
+    return { ok: false, reason: "hw is only valid on bench_result" };
+  }
+  const payloadError = validatePayload(e.event, e.payload);
+  if (payloadError !== null) return { ok: false, reason: payloadError };
+  return { ok: true, event: e };
+}
+
+// src/telemetry/queue.ts
+var MAX_QUEUED_EVENTS = 500;
+function queueDir(dataDir) {
+  return join19(dataDir, "telemetry", "queue");
+}
+function enqueue(dataDir, event) {
+  try {
+    const result = validateEvent(event);
+    if (!result.ok) return false;
+    const dir = queueDir(dataDir);
+    mkdirSync10(dir, { recursive: true });
+    writeFileSync8(join19(dir, `${Date.now()}-${randomUUID4()}.json`), JSON.stringify(result.event));
+    trim(dir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readQueue(dataDir) {
+  const dir = queueDir(dataDir);
+  let files;
+  try {
+    files = readdirSync6(dir).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of files) {
+    try {
+      const event = JSON.parse(readFileSync7(join19(dir, file), "utf8"));
+      if (validateEvent(event).ok) out.push({ file, event });
+      else remove(dataDir, file);
+    } catch {
+      remove(dataDir, file);
+    }
+  }
+  return out;
+}
+function remove(dataDir, file) {
+  try {
+    rmSync10(join19(queueDir(dataDir), file), { force: true });
+  } catch {
+  }
+}
+function trim(dir) {
+  try {
+    const files = readdirSync6(dir).filter((f) => f.endsWith(".json")).sort();
+    for (const stale of files.slice(0, Math.max(0, files.length - MAX_QUEUED_EVENTS))) {
+      rmSync10(join19(dir, stale), { force: true });
+    }
+  } catch {
+  }
+}
+
+// src/telemetry/ledger.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11 } from "fs";
+import { join as join20 } from "path";
+var DAILY_KEEP = 30;
+function ledgerPath(dataDir) {
+  return join20(dataDir, "telemetry", "ledger.json");
+}
+function read(dataDir) {
+  try {
+    const parsed = JSON.parse(readFileSync8(ledgerPath(dataDir), "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((k) => typeof k === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function claimOnce(dataDir, key) {
+  try {
+    const keys = read(dataDir);
+    if (keys.includes(key)) return false;
+    keys.push(key);
+    const dailies = keys.filter((k) => k.startsWith("daily:")).slice(-DAILY_KEEP);
+    const rest = keys.filter((k) => !k.startsWith("daily:"));
+    mkdirSync11(join20(dataDir, "telemetry"), { recursive: true });
+    writeFileSync9(ledgerPath(dataDir), JSON.stringify([...rest, ...dailies]));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/telemetry/first-load.ts
+function reportModelLoad(dataDir, emitter, outcome, failReason) {
+  try {
+    if (!emitter.canSend("model_first_load")) return;
+    if (!claimOnce(dataDir, "once:model_first_load")) return;
+    emitter.emit(
+      "model_first_load",
+      outcome === "fail" ? { outcome, failReason } : { outcome }
+    );
+  } catch {
+  }
+}
+
+// src/telemetry/classify.ts
+var OOM_SIGNS = [
+  "out of memory",
+  "outofmemory",
+  "failed to allocate",
+  "alloc_buffer",
+  "memory allocation of size",
+  "cudamalloc",
+  "insufficient memory"
+];
+var ARCH_SIGNS = ["unknown model architecture", "unsupported model architecture", "unsupported architecture"];
+var GGUF_SIGNS = ["invalid magic", "error loading model", "failed to load model", "gguf_init", "corrupt"];
+function classifyLoadFailure(err7) {
+  if (!err7) return "other";
+  if (err7.code === "readiness_timeout") return "timeout";
+  if (err7.code === "engine_unsupported") return "no_engine";
+  const haystack = [err7.message ?? "", ...err7.logTail ?? []].join("\n").toLowerCase();
+  if (haystack.includes("no_active_engine")) return "no_engine";
+  if (haystack.includes("no_such_model")) return "bad_gguf";
+  if (OOM_SIGNS.some((s) => haystack.includes(s))) return "oom";
+  if (ARCH_SIGNS.some((s) => haystack.includes(s))) return "unsupported_arch";
+  if (GGUF_SIGNS.some((s) => haystack.includes(s))) return "bad_gguf";
+  return "other";
+}
+function classifyBenchFailure(results) {
+  if (results.some((r) => r.outcome === "oom")) return "oom";
+  if (results.some((r) => r.outcome === "timeout")) return "timeout";
+  return "other";
+}
+
+// src/telemetry/disabled.ts
+var TELEMETRY_ENV = "TURBOLLM_TELEMETRY";
+var OFF_VALUES = /* @__PURE__ */ new Set(["off", "0", "false", "no"]);
+function telemetryDisabled() {
+  const raw = process.env[TELEMETRY_ENV];
+  if (raw === void 0) return false;
+  return OFF_VALUES.has(raw.trim().toLowerCase());
+}
+
 // src/models/card-sampling.ts
 var FIELDS = [
   { key: "temp", alias: "temp(?:erature)?", min: 0, max: 2 },
@@ -7609,6 +8009,11 @@ var BenchRunner = class {
   logWinner = null;
   // The finished run's winning candidate, held (not persisted) until the user clicks Save.
   winning = null;
+  /** Journey telemetry (ADR-299 `model_first_load`). Set post-construction in
+   *  cli.ts, matching `Manager.onLoadSettled`'s wiring — the Emitter is built
+   *  after BenchRunner in the daemon's startup order. Absent under tests, which
+   *  construct BenchRunner directly and never exercise `run()`. */
+  telemetry;
   /** Live state for GET /status. */
   status() {
     return this.state;
@@ -7627,6 +8032,14 @@ var BenchRunner = class {
     this.cancelled = true;
     this.abort?.abort();
   }
+  /** Report `model_first_load` for a sweep's conclusion (ADR-299). A no-op when
+   *  no Emitter was injected (absent under tests, which never call `run()`).
+   *  Only the FIRST sweep's outcome across an install's lifetime is recorded —
+   *  see `reportModelLoad`'s own once-only claim — so a re-tune later on
+   *  cannot overwrite it. */
+  reportFirstLoad(outcome, failReason) {
+    if (this.telemetry) reportModelLoad(this.store.dir(), this.telemetry, outcome, failReason);
+  }
   /** Stop the engine — force-killed immediately when the run is cancelled (the user is actively
    *  waiting for it to stop, ADR-220), gracefully otherwise (lets llama-server release resources
    *  cleanly between candidates during a normal run). Every stop in this file goes through this
@@ -7739,11 +8152,13 @@ var BenchRunner = class {
         await this.stopEngine();
       }
       if (this.cancelled) {
+        this.reportFirstLoad("cancelled");
         this.state = { running: false, modelKey, done: true, candidates: results };
         return;
       }
       const profile = recommended && hasAnySampling(recommended) ? { ...best.profile, sampling: { ...best.profile.sampling, ...recommended } } : best.profile;
       const kvAdvisory = kvSpeedAdvisory(best.cand.tps, profile.kvTypeK, caps.kvTypes);
+      this.reportFirstLoad("ok");
       this.winning = { modelKey, profile, cand: best.cand, entry, sys, engineVersion: active?.version ?? "", engineId: active?.id ?? "" };
       this.logWinner = { params: best.cand.params, tps: best.cand.tps ?? 0, prefillTps: best.cand.prefillTps, ttftMs: best.cand.ttftMs ?? 0, vramMb: best.cand.vramMb };
       this.state = {
@@ -7773,6 +8188,7 @@ var BenchRunner = class {
     } else {
       const memoryBound = results.length > 0 && results.every((r) => r.outcome === "oom");
       const err7 = this.cancelled ? void 0 : memoryBound ? `This model doesn't fit on your GPU at ${baseProfile.ctx.toLocaleString()} context \u2014 even with maximum CPU offload it ran out of VRAM. Lower the context length and try again.` : "No candidate completed successfully.";
+      this.reportFirstLoad(this.cancelled ? "cancelled" : "fail", this.cancelled ? void 0 : classifyBenchFailure(results));
       this.state = { running: false, modelKey, done: true, error: err7, candidates: results };
     }
   }
@@ -7982,16 +8398,16 @@ var BenchRunner = class {
       await this.stopEngine();
       return fail("crash");
     }
-    const logPath = this.manager.logPath();
+    const logPath2 = this.manager.logPath();
     const benchMessages = buildBenchMessages(profile.ctx);
     phase("warming up\u2026");
-    const warm = await this.prefillProbe(target, benchMessages, remaining(), logPath, stepPrefix);
+    const warm = await this.prefillProbe(target, benchMessages, remaining(), logPath2, stepPrefix);
     if (warm !== "ok") {
       await this.stopEngine();
       return fail(warm.fault);
     }
     phase("measuring t/s\u2026");
-    const measured = await this.runChatWatched(target, benchMessages, 128, remaining(), logPath);
+    const measured = await this.runChatWatched(target, benchMessages, 128, remaining(), logPath2);
     const vramAfter = await readGpuVramMb(sys);
     await this.stopEngine();
     if ("fault" in measured) return fail(measured.fault);
@@ -8003,7 +8419,7 @@ var BenchRunner = class {
    *  log (oom). Honors cancel + the global deadline. */
   async awaitReady(testDeadline) {
     const deadline = Math.min(Date.now() + READY_TIMEOUT_MS, testDeadline, this.deadline);
-    const logPath = this.manager.logPath();
+    const logPath2 = this.manager.logPath();
     for (; ; ) {
       await sleep2(400);
       if (this.cancelled) return "crash";
@@ -8014,7 +8430,7 @@ var BenchRunner = class {
         if (tail.some((l) => OOM_RE.test(l))) return "oom";
         return "crash";
       }
-      if (logPath && OOM_RE.test(readLiveTail(logPath))) return "oom";
+      if (logPath2 && OOM_RE.test(readLiveTail(logPath2))) return "oom";
       if (Date.now() > deadline) return "timeout";
     }
   }
@@ -8038,7 +8454,7 @@ var BenchRunner = class {
    *  in seconds instead of hanging out the per-test budget. A watchdog polls the engine state + the
    *  live engine log; on an OOM / "device not ready" / process death it aborts the request and the
    *  result is classified accordingly. Returns the timing, or a `fault` outcome. */
-  async runChatWatched(target, messages, maxTokens, budgetMs, logPath) {
+  async runChatWatched(target, messages, maxTokens, budgetMs, logPath2) {
     const probe2 = new AbortController();
     let fault = null;
     const watch = (async () => {
@@ -8055,7 +8471,7 @@ var BenchRunner = class {
           probe2.abort();
           return;
         }
-        if (logPath && OOM_RE.test(readLiveTail(logPath))) {
+        if (logPath2 && OOM_RE.test(readLiveTail(logPath2))) {
           fault = "oom";
           probe2.abort();
           return;
@@ -8082,7 +8498,7 @@ var BenchRunner = class {
    *  out the whole budget. Also aborts on an engine fault (OOM / "device not ready" / process death).
    *  Returns 'ok' once prefill completes (generation starts) — a config that gets here is viable and
    *  the warm prompt cache makes the following measured request fast and accurate. */
-  async prefillProbe(target, messages, budgetMs, logPath, stepPrefix) {
+  async prefillProbe(target, messages, budgetMs, logPath2, stepPrefix) {
     const probe2 = new AbortController();
     let fault = null;
     const watch = (async () => {
@@ -8099,7 +8515,7 @@ var BenchRunner = class {
           probe2.abort();
           return;
         }
-        if (logPath && OOM_RE.test(readLiveTail(logPath))) {
+        if (logPath2 && OOM_RE.test(readLiveTail(logPath2))) {
           fault = "oom";
           probe2.abort();
           return;
@@ -8321,21 +8737,23 @@ var BenchRunner = class {
   }
   /** Queue an anonymized bench_result telemetry event (spec 09 §3) — ONLY when
    *  telemetry is on. Built from whitelisted fields only (never prompts, paths,
-   *  tokens). No uploader (post-launch); just a queue file. Fully fail-safe. */
+   *  tokens). Validation, bounding and fail-safety live in `telemetry/queue`
+   *  (ADR-299); this method owns only the consent check and the payload shape. */
   queueTelemetry(record, entry, sys, appVersion, engineVersion) {
     try {
+      if (telemetryDisabled()) return;
       const cfg2 = this.store.snapshot();
       const level = cfg2.telemetry.level;
       if (level !== "anon" && level !== "full") return;
       let machineId = cfg2.telemetry.machineId;
       if (!machineId) {
-        machineId = randomUUID4();
+        machineId = randomUUID5();
         this.store.update((c) => {
           if (!c.telemetry.machineId) c.telemetry.machineId = machineId;
         });
       }
-      const event = {
-        schema: 1,
+      enqueue(this.store.dir(), {
+        schema: TELEMETRY_SCHEMA_VERSION,
         event: "bench_result",
         ts: record.ts,
         machineId,
@@ -8351,10 +8769,7 @@ var BenchRunner = class {
           params: record.params,
           result: { tps: record.tps, ttftMs: record.ttftMs, vramMb: record.vramMb, outcome: "ok" }
         }
-      };
-      const queueDir = join19(this.store.dir(), "telemetry", "queue");
-      mkdirSync10(queueDir, { recursive: true });
-      writeFileSync8(join19(queueDir, `${randomUUID4()}.json`), JSON.stringify(event));
+      });
     } catch {
     }
   }
@@ -8589,7 +9004,7 @@ function sleep2(ms) {
 }
 function readLiveTail(path) {
   try {
-    return readFileSync7(path, "utf8").slice(-8e3);
+    return readFileSync9(path, "utf8").slice(-8e3);
   } catch {
     return "";
   }
@@ -9678,11 +10093,11 @@ async function backfillPublishedDates(results) {
       try {
         const reader = resp.body.getReader();
         const decoder = new TextDecoder();
-        let read = 0;
-        while (read < DATE_PROBE_MAX_BYTES) {
+        let read2 = 0;
+        while (read2 < DATE_PROBE_MAX_BYTES) {
           const { done, value } = await reader.read();
           if (done) break;
-          read += value.byteLength;
+          read2 += value.byteLength;
           html += decoder.decode(value, { stream: true });
         }
         await reader.cancel().catch(() => {
@@ -10297,7 +10712,7 @@ var GenerationGate = class {
 };
 
 // src/agents/task-state.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var MAX_TASKS = 50;
 var KEEP_DONE_MS = 5 * 6e4;
 var AgentTaskState = class {
@@ -10305,7 +10720,7 @@ var AgentTaskState = class {
   /** Begin a task; returns its id (use it for step/finish). */
   start(kind, agentId, label, convId) {
     this.gc();
-    const id = randomUUID5();
+    const id = randomUUID6();
     this.tasks.set(id, { id, kind, convId, agentId, label, status: "running", steps: [], startedAt: Date.now() });
     return id;
   }
@@ -10356,7 +10771,7 @@ var AgentTaskState = class {
 import { spawn as spawn4 } from "child_process";
 import { homedir as homedir3 } from "os";
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { join as join20, dirname as dirname8 } from "path";
+import { join as join21, dirname as dirname8 } from "path";
 var AUTH_TOKEN = "turbollm-local";
 var SUPPORTED = {
   claude: {
@@ -10494,13 +10909,13 @@ Add the "turbollm" provider by hand (see the Connect screen: TurboLLM UI \u2192
   };
 }
 async function prepareOpencode(base2, apiKey, _modelKey, modelName, fs2 = realFs) {
-  const path = join20(fs2.home, ".config", "opencode", "opencode.json");
-  const read = await readConfigObject(fs2, path);
-  if ("corrupt" in read) return corruptConfigError(path, "opencode");
-  const cfg2 = read.obj;
+  const path = join21(fs2.home, ".config", "opencode", "opencode.json");
+  const read2 = await readConfigObject(fs2, path);
+  if ("corrupt" in read2) return corruptConfigError(path, "opencode");
+  const cfg2 = read2.obj;
   const provider = asObject(cfg2.provider);
   if (!provider) return corruptConfigError(path, "opencode");
-  if (read.lenient) {
+  if (read2.lenient) {
     return providerAlreadyPointsHere(provider.turbollm, base2) ? { ok: true } : commentedConfigError(path, "opencode");
   }
   provider.turbollm = {
@@ -10514,13 +10929,13 @@ async function prepareOpencode(base2, apiKey, _modelKey, modelName, fs2 = realFs
   return { ok: true };
 }
 async function prepareKilo(base2, apiKey, _modelKey, modelName, fs2 = realFs) {
-  const path = join20(fs2.home, ".config", "kilo", "kilo.jsonc");
-  const read = await readConfigObject(fs2, path);
-  if ("corrupt" in read) return corruptConfigError(path, "Kilo Code");
-  const cfg2 = read.obj;
+  const path = join21(fs2.home, ".config", "kilo", "kilo.jsonc");
+  const read2 = await readConfigObject(fs2, path);
+  if ("corrupt" in read2) return corruptConfigError(path, "Kilo Code");
+  const cfg2 = read2.obj;
   const provider = asObject(cfg2.provider);
   if (!provider) return corruptConfigError(path, "Kilo Code");
-  if (read.lenient) {
+  if (read2.lenient) {
     return providerAlreadyPointsHere(provider.turbollm, base2) ? { ok: true } : commentedConfigError(path, "Kilo Code");
   }
   provider.turbollm = {
@@ -10535,16 +10950,16 @@ async function prepareKilo(base2, apiKey, _modelKey, modelName, fs2 = realFs) {
   return { ok: true };
 }
 async function prepareOpenclaw(base2, apiKey, modelKey, modelName, fs2 = realFs) {
-  const path = join20(fs2.home, ".config", "openclaw", "openclaw.json");
-  const read = await readConfigObject(fs2, path);
-  if ("corrupt" in read) return corruptConfigError(path, "openclaw");
-  const cfg2 = read.obj;
+  const path = join21(fs2.home, ".config", "openclaw", "openclaw.json");
+  const read2 = await readConfigObject(fs2, path);
+  if ("corrupt" in read2) return corruptConfigError(path, "openclaw");
+  const cfg2 = read2.obj;
   const models = asObject(cfg2.models);
   const providers = models && asObject(models.providers);
   const agents = asObject(cfg2.agents);
   const defaults = agents && asObject(agents.defaults);
   if (!models || !providers || !agents || !defaults) return corruptConfigError(path, "openclaw");
-  if (read.lenient) {
+  if (read2.lenient) {
     return providerAlreadyPointsHere(providers.turbollm, base2) ? { ok: true } : commentedConfigError(path, "openclaw");
   }
   providers.turbollm = {
@@ -10563,7 +10978,7 @@ async function prepareOpenclaw(base2, apiKey, modelKey, modelName, fs2 = realFs)
   return { ok: true };
 }
 async function preparePi(base2, apiKey, modelKey, modelName, fs2 = realFs) {
-  const modelsPath = join20(fs2.home, ".pi", "agent", "models.json");
+  const modelsPath = join21(fs2.home, ".pi", "agent", "models.json");
   const modelsRead = await readConfigObject(fs2, modelsPath);
   if ("corrupt" in modelsRead) return corruptConfigError(modelsPath, "pi");
   const modelsCfg = modelsRead.obj;
@@ -10582,7 +10997,7 @@ async function preparePi(base2, apiKey, modelKey, modelName, fs2 = realFs) {
     await fs2.mkdir(dirname8(modelsPath));
     await fs2.writeFile(modelsPath, JSON.stringify(modelsCfg, null, 2) + "\n");
   }
-  const settingsPath = join20(fs2.home, ".pi", "agent", "settings.json");
+  const settingsPath = join21(fs2.home, ".pi", "agent", "settings.json");
   const settingsRead = await readConfigObject(fs2, settingsPath);
   if ("corrupt" in settingsRead) return corruptConfigError(settingsPath, "pi");
   const settingsCfg = settingsRead.obj;
@@ -10818,18 +11233,18 @@ Install it:  ${spec.install}
 }
 
 // src/daemon-pid.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, unlinkSync, existsSync as existsSync18 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, unlinkSync, existsSync as existsSync18 } from "fs";
+import { join as join22 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 function writePidfile(dir, pid, port2) {
-  const path = join21(dir, "daemon.pid");
-  writeFileSync9(path, JSON.stringify({ pid, port: port2 }));
+  const path = join22(dir, "daemon.pid");
+  writeFileSync10(path, JSON.stringify({ pid, port: port2 }));
 }
 function readPidfile(dir) {
-  const path = join21(dir, "daemon.pid");
+  const path = join22(dir, "daemon.pid");
   if (!existsSync18(path)) return null;
   try {
-    const raw = readFileSync8(path, "utf8");
+    const raw = readFileSync10(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && typeof parsed.pid === "number" && typeof parsed.port === "number") {
       return parsed;
@@ -10847,7 +11262,7 @@ function resolveDaemonPort(dir, explicitPort, fallbackPort) {
 }
 function removePidfile(dir) {
   try {
-    unlinkSync(join21(dir, "daemon.pid"));
+    unlinkSync(join22(dir, "daemon.pid"));
   } catch {
   }
 }
@@ -11074,16 +11489,16 @@ function runMcpServer(baseUrl, version2) {
 // src/server.ts
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { existsSync as existsSync24, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync17, statSync as statSync6 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname11, join as join30, normalize as normalize2 } from "path";
+import { dirname as dirname11, join as join32, normalize as normalize2 } from "path";
 import { Agent, setGlobalDispatcher } from "undici";
 
 // src/api/routes.ts
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync11, readdirSync as readdirSync9, realpathSync, rmSync as rmSync13, statSync as statSync5, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync16, readFileSync as readFileSync14, readdirSync as readdirSync10, realpathSync, rmSync as rmSync14, statSync as statSync5, writeFileSync as writeFileSync14 } from "fs";
 import { execFileSync as execFileSync6 } from "child_process";
-import { basename as basename3, dirname as dirname9, join as join26, resolve } from "path";
+import { basename as basename3, dirname as dirname9, join as join28, resolve } from "path";
 
 // src/comfyui/gate-template.ts
 var GATE_VERSION = 2;
@@ -11222,7 +11637,7 @@ __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]
 }
 
 // src/api/routes.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { homedir as homedir4, networkInterfaces as networkInterfaces2 } from "os";
 
 // src/chat/chat-routes.ts
@@ -11618,8 +12033,8 @@ function buildSaveSkillTool(onSaveSkill) {
 }
 
 // src/agents/skills.ts
-import { join as join22 } from "path";
-import { existsSync as existsSync19, readFileSync as readFileSync9, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, rmSync as rmSync10, readdirSync as readdirSync6 } from "fs";
+import { join as join23 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync11, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, rmSync as rmSync11, readdirSync as readdirSync7 } from "fs";
 var BUILTIN_SKILLS = [
   {
     id: "filesystem",
@@ -11708,22 +12123,22 @@ var SkillStore = class {
   }
   dataDir;
   get skillsDir() {
-    return join22(this.dataDir, "skills");
+    return join23(this.dataDir, "skills");
   }
   list() {
     const skills = [...BUILTIN_SKILLS];
     const idSet = new Set(skills.map((s) => s.id));
     if (!existsSync19(this.skillsDir)) return skills;
-    for (const e of readdirSync6(this.skillsDir, { withFileTypes: true })) {
+    for (const e of readdirSync7(this.skillsDir, { withFileTypes: true })) {
       let skill = null;
       let id = "";
       if (e.isDirectory()) {
         id = e.name;
-        const md = join22(this.skillsDir, e.name, "SKILL.md");
+        const md = join23(this.skillsDir, e.name, "SKILL.md");
         if (existsSync19(md)) skill = this.loadMd(id, md);
       } else if (e.isFile() && e.name.endsWith(".json")) {
         id = e.name.slice(0, -5);
-        skill = this.loadJson(join22(this.skillsDir, e.name), id);
+        skill = this.loadJson(join23(this.skillsDir, e.name), id);
       }
       if (!skill || !id || idSet.has(id)) continue;
       idSet.add(id);
@@ -11739,30 +12154,30 @@ var SkillStore = class {
     return this.list().find((s) => s.id === id);
   }
   has(id) {
-    return isValidSkillId(id) && existsSync19(join22(this.skillsDir, id, "SKILL.md"));
+    return isValidSkillId(id) && existsSync19(join23(this.skillsDir, id, "SKILL.md"));
   }
   write(skill) {
     if (!isValidSkillId(skill.id)) throw new Error(`Invalid skill id: ${skill.id}`);
-    const dir = join22(this.skillsDir, skill.id);
-    mkdirSync11(dir, { recursive: true });
-    writeFileSync10(join22(dir, "SKILL.md"), toSkillMd(skill), "utf8");
+    const dir = join23(this.skillsDir, skill.id);
+    mkdirSync12(dir, { recursive: true });
+    writeFileSync11(join23(dir, "SKILL.md"), toSkillMd(skill), "utf8");
   }
   delete(id) {
     if (!isValidSkillId(id)) return;
-    rmSync10(join22(this.skillsDir, id), { recursive: true, force: true });
-    const legacy = join22(this.skillsDir, `${id}.json`);
-    if (existsSync19(legacy)) rmSync10(legacy);
+    rmSync11(join23(this.skillsDir, id), { recursive: true, force: true });
+    const legacy = join23(this.skillsDir, `${id}.json`);
+    if (existsSync19(legacy)) rmSync11(legacy);
   }
   loadMd(id, path) {
     try {
-      return fromSkillMd(id, readFileSync9(path, "utf8"));
+      return fromSkillMd(id, readFileSync11(path, "utf8"));
     } catch {
       return null;
     }
   }
   loadJson(path, id) {
     try {
-      const data = JSON.parse(readFileSync9(path, "utf8"));
+      const data = JSON.parse(readFileSync11(path, "utf8"));
       if (!data.name || typeof data.name !== "string") return null;
       if (!data.instructions || typeof data.instructions !== "string") return null;
       return { id, name: data.name, description: data.description || "", instructions: data.instructions, tools: Array.isArray(data.tools) ? data.tools : [], builtin: false };
@@ -11784,7 +12199,7 @@ function importSkillsFromFolder(store2, folder, opts = {}) {
     if (depth > 5 || found.length >= max) return;
     let entries;
     try {
-      entries = readdirSync6(dir, { withFileTypes: true });
+      entries = readdirSync7(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -11792,14 +12207,14 @@ function importSkillsFromFolder(store2, folder, opts = {}) {
     if (skillFile) {
       const id = toSkillId(dir.split(/[\\/]/).pop() || "skill");
       try {
-        found.push({ id, text: readFileSync9(join22(dir, skillFile.name), "utf8") });
+        found.push({ id, text: readFileSync11(join23(dir, skillFile.name), "utf8") });
       } catch {
       }
       return;
     }
     for (const e of entries) {
       if (found.length >= max) return;
-      if (e.isDirectory() && !e.name.startsWith(".")) walk2(join22(dir, e.name), depth + 1);
+      if (e.isDirectory() && !e.name.startsWith(".")) walk2(join23(dir, e.name), depth + 1);
     }
   };
   walk2(folder, 0);
@@ -12960,7 +13375,7 @@ async function autoTitleFromConversation(d, convId) {
 }
 
 // src/auth.ts
-import { createHash as createHash5, randomBytes, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash5, randomBytes, randomUUID as randomUUID7 } from "crypto";
 import { getConnInfo } from "@hono/node-server/conninfo";
 var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
 function hashKey(raw) {
@@ -12978,7 +13393,7 @@ function generateApiKey() {
 function provisionTunnelApiKey(d) {
   const { full, hash, prefix } = generateApiKey();
   const key = {
-    id: randomUUID6(),
+    id: randomUUID7(),
     name: `tunnel-${(/* @__PURE__ */ new Date()).toISOString()}`,
     hash,
     prefix,
@@ -13214,8 +13629,8 @@ async function claudePermissionModeChoices(run = realHelpRunner) {
 
 // src/terminal/terminal-manager.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync10, readdirSync as readdirSync7, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "fs";
-import { join as join23 } from "path";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync12, readdirSync as readdirSync8, rmSync as rmSync12, writeFileSync as writeFileSync12 } from "fs";
+import { join as join24 } from "path";
 
 // src/terminal/pty-session.ts
 import { EventEmitter } from "events";
@@ -13337,21 +13752,21 @@ var PTYSession = class _PTYSession {
 
 // src/terminal/terminal-manager.ts
 function terminalPidDir(dataDir) {
-  return join23(dataDir, "run");
+  return join24(dataDir, "run");
 }
 function terminalPidFile(dataDir, pid) {
-  return join23(terminalPidDir(dataDir), `terminal-${pid}.pid`);
+  return join24(terminalPidDir(dataDir), `terminal-${pid}.pid`);
 }
 function writeTerminalPid(dataDir, pid) {
   try {
-    mkdirSync12(terminalPidDir(dataDir), { recursive: true });
-    writeFileSync11(terminalPidFile(dataDir, pid), JSON.stringify({ pid, owner: process.pid }));
+    mkdirSync13(terminalPidDir(dataDir), { recursive: true });
+    writeFileSync12(terminalPidFile(dataDir, pid), JSON.stringify({ pid, owner: process.pid }));
   } catch {
   }
 }
 function clearTerminalPid(dataDir, pid) {
   try {
-    rmSync11(terminalPidFile(dataDir, pid), { force: true });
+    rmSync12(terminalPidFile(dataDir, pid), { force: true });
   } catch {
   }
 }
@@ -13368,20 +13783,20 @@ function readTerminalPidFiles(dataDir) {
   const dir = terminalPidDir(dataDir);
   let names;
   try {
-    names = readdirSync7(dir).filter((n) => /^terminal-\d+\.pid$/.test(n));
+    names = readdirSync8(dir).filter((n) => /^terminal-\d+\.pid$/.test(n));
   } catch {
     return [];
   }
   const out = [];
   for (const name of names) {
-    const file = join23(dir, name);
+    const file = join24(dir, name);
     try {
-      const { pid, owner } = JSON.parse(readFileSync10(file, "utf8"));
+      const { pid, owner } = JSON.parse(readFileSync12(file, "utf8"));
       if (typeof pid === "number" && pid > 0) out.push({ pid, owner: typeof owner === "number" ? owner : 0, file });
-      else rmSync11(file, { force: true });
+      else rmSync12(file, { force: true });
     } catch {
       try {
-        rmSync11(file, { force: true });
+        rmSync12(file, { force: true });
       } catch {
       }
     }
@@ -13399,7 +13814,7 @@ function reapStaleTerminals(dataDir) {
     } catch {
     }
     try {
-      rmSync11(file, { force: true });
+      rmSync12(file, { force: true });
     } catch {
     }
   }
@@ -13414,7 +13829,7 @@ function killTrackedTerminalsSync(dataDir) {
     } catch {
     }
     try {
-      rmSync11(file, { force: true });
+      rmSync12(file, { force: true });
     } catch {
     }
   }
@@ -14241,9 +14656,9 @@ function catalogEngine(id) {
 
 // src/engines/cuda-provision.ts
 import { execFile as execFile11 } from "child_process";
-import { cpSync as cpSync2, existsSync as existsSync20, mkdirSync as mkdirSync13, readdirSync as readdirSync8, rmSync as rmSync12 } from "fs";
+import { cpSync as cpSync2, existsSync as existsSync20, mkdirSync as mkdirSync14, readdirSync as readdirSync9, rmSync as rmSync13 } from "fs";
 import { tmpdir } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import { promisify as promisify8 } from "util";
 var execFileP8 = promisify8(execFile11);
 var REDIST_BASE = "https://developer.download.nvidia.com/compute/cuda/redist/";
@@ -14298,9 +14713,9 @@ async function provisionCuda(dataDir, onProgress, signal) {
     phase: "resolving",
     message: `Using CUDA ${version2}${driverMax ? ` (driver supports up to ${driverMax})` : ""}.`
   });
-  const root = join24(dataDir, "cuda", version2);
-  const binDir = join24(root, "bin");
-  if (existsSync20(join24(binDir, "nvcc.exe"))) {
+  const root = join25(dataDir, "cuda", version2);
+  const binDir = join25(root, "bin");
+  if (existsSync20(join25(binDir, "nvcc.exe"))) {
     onProgress({ phase: "assembling", message: `CUDA ${version2} already downloaded \u2014 reusing it.` });
     return { root, binDir, version: version2 };
   }
@@ -14315,38 +14730,38 @@ async function provisionCuda(dataDir, onProgress, signal) {
     const rel = relOf(id);
     if (rel) components.push({ id, url: REDIST_BASE + rel });
   }
-  const work = join24(tmpdir(), `tllm-cuda-${version2}`);
-  rmSync12(work, { recursive: true, force: true });
-  mkdirSync13(work, { recursive: true });
+  const work = join25(tmpdir(), `tllm-cuda-${version2}`);
+  rmSync13(work, { recursive: true, force: true });
+  mkdirSync14(work, { recursive: true });
   const stageRoot = `${root}.partial`;
-  rmSync12(stageRoot, { recursive: true, force: true });
-  mkdirSync13(stageRoot, { recursive: true });
+  rmSync13(stageRoot, { recursive: true, force: true });
+  mkdirSync14(stageRoot, { recursive: true });
   try {
     for (let i = 0; i < components.length; i++) {
       const { id, url } = components[i];
-      const zip = join24(work, `${id}.zip`);
+      const zip = join25(work, `${id}.zip`);
       onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: 0 });
       await downloadFile(url, zip, (p) => onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: p.pct }), signal);
-      const exDir = join24(work, id);
-      mkdirSync13(exDir, { recursive: true });
+      const exDir = join25(work, id);
+      mkdirSync14(exDir, { recursive: true });
       onProgress({ phase: "extracting", message: `Extracting ${id}\u2026` });
       await extractArchive(zip, exDir);
-      const inner = readdirSync8(exDir).map((n) => join24(exDir, n)).find((p) => existsSync20(join24(p, "include")) || existsSync20(join24(p, "bin")) || existsSync20(join24(p, "lib")));
-      const srcRoot = inner ?? join24(exDir, readdirSync8(exDir)[0] ?? "");
+      const inner = readdirSync9(exDir).map((n) => join25(exDir, n)).find((p) => existsSync20(join25(p, "include")) || existsSync20(join25(p, "bin")) || existsSync20(join25(p, "lib")));
+      const srcRoot = inner ?? join25(exDir, readdirSync9(exDir)[0] ?? "");
       cpSync2(srcRoot, stageRoot, { recursive: true, force: true });
-      rmSync12(zip, { force: true });
+      rmSync13(zip, { force: true });
     }
-    if (!existsSync20(join24(stageRoot, "bin", "nvcc.exe"))) {
+    if (!existsSync20(join25(stageRoot, "bin", "nvcc.exe"))) {
       throw new Error("Assembled CUDA toolkit is missing bin/nvcc.exe \u2014 the component set may have changed.");
     }
-    rmSync12(root, { recursive: true, force: true });
-    mkdirSync13(join24(dataDir, "cuda"), { recursive: true });
+    rmSync13(root, { recursive: true, force: true });
+    mkdirSync14(join25(dataDir, "cuda"), { recursive: true });
     cpSync2(stageRoot, root, { recursive: true, force: true });
     onProgress({ phase: "assembling", message: `CUDA ${version2} ready.` });
     return { root, binDir, version: version2 };
   } finally {
-    rmSync12(work, { recursive: true, force: true });
-    rmSync12(stageRoot, { recursive: true, force: true });
+    rmSync13(work, { recursive: true, force: true });
+    rmSync13(stageRoot, { recursive: true, force: true });
   }
 }
 
@@ -14423,7 +14838,7 @@ function recommendEngines(p, engines) {
 // src/artifacts/screenshot.ts
 import { existsSync as existsSync21 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function chromeCandidates() {
   const env = process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_PATH;
   const out = env ? [env] : [];
@@ -14432,10 +14847,10 @@ function chromeCandidates() {
     const pfx86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
     const local = process.env["LOCALAPPDATA"] || "";
     for (const base2 of [pf, pfx86, local].filter(Boolean)) {
-      out.push(join25(base2, "Google", "Chrome", "Application", "chrome.exe"));
+      out.push(join26(base2, "Google", "Chrome", "Application", "chrome.exe"));
     }
     for (const base2 of [pfx86, pf].filter(Boolean)) {
-      out.push(join25(base2, "Microsoft", "Edge", "Application", "msedge.exe"));
+      out.push(join26(base2, "Microsoft", "Edge", "Application", "msedge.exe"));
     }
   } else if (process.platform === "darwin") {
     out.push(
@@ -14516,6 +14931,86 @@ async function screenshotArtifact(html, opts) {
   }
 }
 
+// src/telemetry/log.ts
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync13, mkdirSync as mkdirSync15 } from "fs";
+import { join as join27 } from "path";
+var MAX_LOGGED = 200;
+function logPath(dataDir) {
+  return join27(dataDir, "telemetry", "sent.json");
+}
+function readSentLog(dataDir) {
+  try {
+    const parsed = JSON.parse(readFileSync13(logPath(dataDir), "utf8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function recordSent(dataDir, events) {
+  try {
+    const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+    const fresh = events.map((event) => ({ sentAt, event })).reverse();
+    const next = [...fresh, ...readSentLog(dataDir)].slice(0, MAX_LOGGED);
+    mkdirSync15(join27(dataDir, "telemetry"), { recursive: true });
+    writeFileSync13(logPath(dataDir), JSON.stringify(next));
+  } catch {
+  }
+}
+
+// src/telemetry/uploader.ts
+var INGEST_URL = "https://t.turbollm.dev/v1/events";
+function mayTransmit(level) {
+  return level === "anon" || level === "full";
+}
+async function flush(dataDir, level, transport = httpTransport) {
+  try {
+    const queued = readQueue(dataDir);
+    if (telemetryDisabled() || !mayTransmit(level)) {
+      for (const q of queued) remove(dataDir, q.file);
+      return;
+    }
+    if (queued.length === 0) return;
+    const events = queued.map((q) => q.event);
+    const accepted = await transport(events);
+    if (accepted) {
+      recordSent(dataDir, events);
+      for (const q of queued) remove(dataDir, q.file);
+    }
+  } catch {
+  }
+}
+var httpTransport = async (events) => {
+  const signal = AbortSignal.timeout(1e4);
+  const res = await fetch(INGEST_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(events),
+    signal
+  });
+  return res.ok;
+};
+
+// src/telemetry/consent.ts
+var httpTransport2 = async (events) => {
+  const res = await fetch(INGEST_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(events),
+    signal: AbortSignal.timeout(1e4)
+  });
+  return res.ok;
+};
+async function sendConsentChoice(dataDir, level, transport = httpTransport2) {
+  try {
+    if (telemetryDisabled()) return;
+    if (!CONSENT_LEVELS.includes(level)) return;
+    if (!claimOnce(dataDir, "consent_choice_sent")) return;
+    const ping = { schema: TELEMETRY_SCHEMA_VERSION, event: "consent_choice", level };
+    if (await transport([ping])) recordSent(dataDir, [ping]);
+  } catch {
+  }
+}
+
 // src/api/routes.ts
 function err3(c, status, code, message) {
   return c.json({ error: { code, message } }, status);
@@ -14577,7 +15072,7 @@ function registerApi(app2, d) {
         let installedVersion = null;
         if (gatePath) {
           try {
-            const src = readFileSync11(join26(gatePath, "__init__.py"), "utf-8");
+            const src = readFileSync14(join28(gatePath, "__init__.py"), "utf-8");
             const m = src.match(/^GATE_VERSION\s*=\s*(\d+)/m);
             if (m) installedVersion = Number(m[1]);
           } catch {
@@ -14617,7 +15112,7 @@ function registerApi(app2, d) {
     const sys = getSysInfo();
     const vendor = primaryVendor(sys);
     const recommended = recommendBackendId(vendor, sys.gpus.length > 0);
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const active = d.registry.active();
     const regEngines = d.registry.list().engines;
     const backendOf = (p) => p.match(/llama\.cpp-[^/\\]+-(cuda|rocm|sycl|vulkan|metal|cpu)/i)?.[1]?.toLowerCase();
@@ -14638,7 +15133,7 @@ function registerApi(app2, d) {
         engineId: eng?.id ?? ""
       };
     });
-    const mlxVenvPy = join26(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
+    const mlxVenvPy = join28(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
     const mlxInstalledOnDisk = existsSync22(mlxVenvPy);
     const mlxEngine = regEngines.find((e) => e.kind === "mlx");
     const mlx = {
@@ -14654,7 +15149,7 @@ function registerApi(app2, d) {
     const b = await body3(c);
     const def = availableBackends().find((x) => x.id === b.backend);
     if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const existing = installedBackendBuild(root, def.id);
     if (existing) {
       return c.json({ accepted: false, alreadyInstalled: true, build: existing.tag });
@@ -14698,7 +15193,7 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/backends/:id/update", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const oldBin = installedBackendBuild(root, def.id)?.bin ?? null;
     if (!oldBin) return err3(c, 409, "not_installed", "Backend is not installed \u2014 download it first.");
     {
@@ -14742,7 +15237,7 @@ function registerApi(app2, d) {
           }
         }
         if (installedTag && installedTag !== latestTag) {
-          rmSync13(backendDir(root, def.id, installedTag), { recursive: true, force: true });
+          rmSync14(backendDir(root, def.id, installedTag), { recursive: true, force: true });
         }
         d.provision.done();
       } catch (e) {
@@ -14757,7 +15252,7 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/backends/:id/enable", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const build2 = installedBackendBuild(root, def.id);
     if (!build2) return err3(c, 409, "not_installed", "Backend is not installed on disk \u2014 download it first.");
     let eng = d.registry.list().engines.find((e) => e.binPath === build2.bin);
@@ -14768,7 +15263,7 @@ function registerApi(app2, d) {
   app2.delete("/api/v1/engines/backends/:id", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const backendDirRe = new RegExp(`[\\\\/]engines[\\\\/]llama\\.cpp-[^\\\\/]+-${def.id}[\\\\/]`);
     const engs = d.registry.list().engines.filter((e) => backendDirRe.test(e.binPath));
     const activeId = d.registry.active()?.id;
@@ -14790,7 +15285,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -14813,7 +15308,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -14830,12 +15325,12 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/engines/catalog", (c) => {
     const regEngines = d.registry.list().engines;
-    const enginesRoot = join26(d.store.dir(), "engines");
+    const enginesRoot = join28(d.store.dir(), "engines");
     const items = catalogForPlatform().map((e) => {
       let installed2;
       let enabled;
       if (e.provision === "pip") {
-        const pyPath = join26(
+        const pyPath = join28(
           enginesRoot,
           e.id,
           "venv",
@@ -14844,7 +15339,7 @@ function registerApi(app2, d) {
         installed2 = existsSync22(pyPath);
         enabled = regEngines.some((x) => x.kind === e.kind);
       } else if (e.id === "turboquant") {
-        const tqDir = join26(enginesRoot, "turboquant");
+        const tqDir = join28(enginesRoot, "turboquant");
         installed2 = existsSync22(tqDir);
         enabled = regEngines.some((x) => /[\\/]engines[\\/]turboquant[\\/]/.test(x.binPath));
       } else if (e.id === "koboldcpp") {
@@ -14914,9 +15409,9 @@ function registerApi(app2, d) {
     const busy = engineWorkBusy(d);
     if (busy) return err3(c, 409, "engine_already_running", busy);
     const name = (b.name ?? "").trim() || void 0;
-    const enginesRoot = join26(d.store.dir(), "engines");
+    const enginesRoot = join28(d.store.dir(), "engines");
     const toolchainDirs = d.store.snapshot().build.toolchainDirs;
-    const buildRoot = join26(enginesRoot, "build", buildDirName(repoUrl, branch, commit));
+    const buildRoot = join28(enginesRoot, "build", buildDirName(repoUrl, branch, commit));
     const ac = new AbortController();
     buildAbort = ac;
     d.build.start(name ?? repoUrl);
@@ -14931,7 +15426,7 @@ function registerApi(app2, d) {
           );
         } catch (e) {
           try {
-            rmSync13(buildRoot, { recursive: true, force: true });
+            rmSync14(buildRoot, { recursive: true, force: true });
           } catch {
           }
           if (e?.name === "AbortError") {
@@ -15026,7 +15521,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -15046,7 +15541,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -15071,14 +15566,14 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("turboquant");
         if (upgrade) {
-          const tqDir = join26(root, "turboquant");
-          if (existsSync22(tqDir)) rmSync13(tqDir, { recursive: true, force: true });
+          const tqDir = join28(root, "turboquant");
+          if (existsSync22(tqDir)) rmSync14(tqDir, { recursive: true, force: true });
         }
         const bin = await provisionTurboquant(
           root,
@@ -15106,7 +15601,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     const hasNvidia = primaryVendor(getSysInfo()) === "nvidia";
     void (async () => {
@@ -15114,7 +15609,7 @@ function registerApi(app2, d) {
         d.provision.start("koboldcpp");
         if (upgrade) {
           const dir = koboldcppDir(root);
-          if (existsSync22(dir)) rmSync13(dir, { recursive: true, force: true });
+          if (existsSync22(dir)) rmSync14(dir, { recursive: true, force: true });
         }
         const rt = await ensureKoboldcpp(root, hasNvidia, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addKoboldcpp(`KoboldCpp (${rt.version})`, rt.binPath, rt.version);
@@ -15137,14 +15632,14 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join26(d.store.dir(), "engines");
+    const root = join28(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("llamafile");
         if (upgrade) {
           const dir = llamafileDir(root);
-          if (existsSync22(dir)) rmSync13(dir, { recursive: true, force: true });
+          if (existsSync22(dir)) rmSync14(dir, { recursive: true, force: true });
         }
         const rt = await ensureLlamafile(root, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addLlamafile(`llamafile (${rt.version})`, rt.binPath, rt.version);
@@ -15244,10 +15739,10 @@ function registerApi(app2, d) {
       }
       d.registry.remove(id);
       if (purge && eng) {
-        const enginesRoot = join26(d.store.dir(), "engines");
+        const enginesRoot = join28(d.store.dir(), "engines");
         const purgeDir = engineInstallDir(eng, enginesRoot);
         if (purgeDir && existsSync22(purgeDir)) {
-          rmSync13(purgeDir, { recursive: true, force: true });
+          rmSync14(purgeDir, { recursive: true, force: true });
         }
         d.registry.forgetCustomSource(customSourceKey(eng));
       }
@@ -15329,16 +15824,16 @@ function registerApi(app2, d) {
     }
     let entries;
     try {
-      entries = readdirSync9(real, { withFileTypes: true }).filter((d2) => !d2.name.startsWith(".")).map((d2) => {
+      entries = readdirSync10(real, { withFileTypes: true }).filter((d2) => !d2.name.startsWith(".")).map((d2) => {
         let isDir = d2.isDirectory();
         if (d2.isSymbolicLink()) {
           try {
-            isDir = statSync5(join26(real, d2.name)).isDirectory();
+            isDir = statSync5(join28(real, d2.name)).isDirectory();
           } catch {
             isDir = false;
           }
         }
-        return { name: d2.name, path: join26(real, d2.name), isDir };
+        return { name: d2.name, path: join28(real, d2.name), isDir };
       }).sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1);
     } catch {
       return err3(c, 400, "fs_read_failed", "Could not read that folder (permission denied or not a directory).");
@@ -15481,17 +15976,17 @@ function registerApi(app2, d) {
     }
     let customNodes;
     if (basename3(root).toLowerCase() === "custom_nodes") customNodes = root;
-    else if (existsSync22(join26(root, "custom_nodes"))) customNodes = join26(root, "custom_nodes");
+    else if (existsSync22(join28(root, "custom_nodes"))) customNodes = join28(root, "custom_nodes");
     else {
       return err3(c, 400, "invalid_config_value", "No 'custom_nodes' folder here. Point me at your ComfyUI folder or its custom_nodes folder.");
     }
     const reqUrl = new URL(c.req.url);
     const port2 = reqUrl.port || (reqUrl.protocol === "https:" ? "443" : "80");
     const base2 = `http://127.0.0.1:${port2}`;
-    const gateDir = join26(customNodes, "turbollm_gate");
+    const gateDir = join28(customNodes, "turbollm_gate");
     try {
-      mkdirSync14(gateDir, { recursive: true });
-      writeFileSync12(join26(gateDir, "__init__.py"), gateNodeSource(base2));
+      mkdirSync16(gateDir, { recursive: true });
+      writeFileSync14(join28(gateDir, "__init__.py"), gateNodeSource(base2));
     } catch (e) {
       return err3(c, 500, "fs_write_failed", `Could not write the gate node: ${e instanceof Error ? e.message : e}`);
     }
@@ -15504,7 +15999,7 @@ function registerApi(app2, d) {
     const dir = d.store.snapshot().comfyui.gatePath;
     if (dir && existsSync22(dir)) {
       try {
-        rmSync13(dir, { recursive: true, force: true });
+        rmSync14(dir, { recursive: true, force: true });
       } catch (e) {
         return err3(c, 500, "fs_write_failed", `Could not remove the gate node: ${e instanceof Error ? e.message : e}`);
       }
@@ -15538,7 +16033,7 @@ function registerApi(app2, d) {
       while (!aborted) {
         const path = d.manager.logPath();
         if (path && existsSync22(path)) {
-          const lines = readFileSync11(path, "utf8").split("\n");
+          const lines = readFileSync14(path, "utf8").split("\n");
           for (; sent < lines.length - 1; sent++) {
             await stream.writeSSE({ event: "line", data: JSON.stringify({ line: lines[sent].replace(/\r$/, "") }) });
           }
@@ -15829,6 +16324,7 @@ function registerApi(app2, d) {
       d.tools?.updateConfig(d.store.snapshot().tools);
       await d.tools?.buildToolDefinitions();
     }
+    if (telemetryLevel !== void 0) void sendConsentChoice(d.store.dir(), telemetryLevel);
     const after = d.store.snapshot().daemon;
     const lanChanged = after.lanBind !== before.lanBind;
     const portChanged = after.port !== before.port;
@@ -15847,9 +16343,9 @@ function registerApi(app2, d) {
     if (transport === "stdio" && !b.command?.trim()) return err3(c, 400, "invalid_config_value", "command is required for stdio transport.");
     if (transport === "sse" && !b.url?.trim()) return err3(c, 400, "invalid_config_value", "url is required for sse transport.");
     if (transport === "sse" && !/^https?:\/\//i.test(b.url ?? "")) return err3(c, 400, "invalid_config_value", "url must be an http(s):// address.");
-    const { randomUUID: randomUUID11 } = await import("crypto");
+    const { randomUUID: randomUUID13 } = await import("crypto");
     const server2 = {
-      id: randomUUID11(),
+      id: randomUUID13(),
       name: b.name.trim(),
       transport,
       enabled: b.enabled !== false,
@@ -15857,7 +16353,7 @@ function registerApi(app2, d) {
     };
     const isMemoryServer = server2.transport === "stdio" && (server2.command?.includes("server-memory") || server2.args?.some((a) => a.includes("server-memory")));
     if (isMemoryServer && !server2.env?.MEMORY_FILE_PATH) {
-      server2.env = { ...server2.env, MEMORY_FILE_PATH: join26(homedir4(), ".turbollm", "mcp-memory.jsonl") };
+      server2.env = { ...server2.env, MEMORY_FILE_PATH: join28(homedir4(), ".turbollm", "mcp-memory.jsonl") };
     }
     d.store.update((cfg2) => {
       cfg2.mcp.servers.push(server2);
@@ -15911,6 +16407,15 @@ function registerApi(app2, d) {
     const level = ["off", "anon", "full"].includes(raw) ? raw : "off";
     return c.json(telemetryPreview(level, d.version));
   });
+  app2.get("/api/v1/telemetry/log", (c) => c.json({ entries: readSentLog(d.store.dir()) }));
+  app2.post("/api/v1/telemetry/regenerate-id", (c) => {
+    const machineId = randomUUID8();
+    d.store.update((cfg2) => {
+      cfg2.telemetry.machineId = machineId;
+    });
+    for (const q of readQueue(d.store.dir())) remove(d.store.dir(), q.file);
+    return c.json({ machineId });
+  });
   app2.get("/api/v1/settings/network", (c) => {
     const cfg2 = d.store.snapshot();
     return c.json({
@@ -16062,7 +16567,7 @@ function registerApi(app2, d) {
     if (!name) return err3(c, 400, "invalid_config_value", "name is required.");
     const { full, hash, prefix } = generateApiKey();
     const key = {
-      id: randomUUID7(),
+      id: randomUUID8(),
       name,
       hash,
       prefix,
@@ -16098,7 +16603,7 @@ function registerApi(app2, d) {
       const keyName = `cli-${cli}`;
       const { full, hash, prefix } = generateApiKey();
       const fresh = {
-        id: randomUUID7(),
+        id: randomUUID8(),
         name: keyName,
         hash,
         prefix,
@@ -16162,6 +16667,13 @@ function settingsPayload(d) {
     lanBind: cfg2.daemon.lanBind,
     requireApiKey: cfg2.daemon.requireApiKey,
     telemetryLevel,
+    // Whether the user has ever actually answered (ADR-299 Decision 4).
+    // `telemetryLevel` above deliberately collapses the first-run 'unset'
+    // sentinel to 'off' so every consumer fails safe — but that also makes
+    // "never asked" indistinguishable from "chose Off", and the first-run
+    // consent card needs exactly that distinction. Hence a separate flag
+    // rather than leaking 'unset' into the level enum.
+    telemetryDecided: cfg2.telemetry.level !== "unset",
     modelDefaults: cfg2.modelDefaults,
     comfyui: cfg2.comfyui,
     gateway: cfg2.gateway,
@@ -16199,7 +16711,12 @@ function settingsPayload(d) {
 }
 function telemetryPreview(level, version2) {
   if (level === "off") {
-    return { level, sends: false, note: "Telemetry is off. Nothing is collected or sent.", payload: null };
+    return {
+      level,
+      sends: true,
+      note: "Telemetry is off. The only thing ever sent is this one-time record of your choice \u2014 no machine id, no hardware, no timestamp. Nothing else, ever.",
+      payload: [{ schema: TELEMETRY_SCHEMA_VERSION, event: "consent_choice", level: "off" }]
+    };
   }
   const sys = getSysInfo();
   const hw = {
@@ -16295,19 +16812,19 @@ function engineInstallDir(eng, enginesRoot) {
     return n.startsWith(norm + "/") || n.startsWith(norm + "\\");
   };
   if (eng.kind === "mlx") {
-    const d = join26(enginesRoot, "mlx", "venv");
+    const d = join28(enginesRoot, "mlx", "venv");
     return inside(d) ? d : null;
   }
   if (eng.kind === "rapid-mlx") {
-    const d = join26(enginesRoot, "rapid-mlx", "venv");
+    const d = join28(enginesRoot, "rapid-mlx", "venv");
     return inside(d) ? d : null;
   }
   if (eng.kind === "vllm") {
-    const d = join26(enginesRoot, "vllm", "venv");
+    const d = join28(enginesRoot, "vllm", "venv");
     return inside(d) ? d : null;
   }
   if (/[\\/]engines[\\/]turboquant[\\/]/.test(eng.binPath)) {
-    const d = join26(enginesRoot, "turboquant");
+    const d = join28(enginesRoot, "turboquant");
     return inside(d) ? d : null;
   }
   if (eng.kind === "koboldcpp") {
@@ -16322,7 +16839,7 @@ function engineInstallDir(eng, enginesRoot) {
   if (srcDir) return inside(srcDir) ? srcDir : null;
   const llamaMatch = eng.binPath.replace(/\\/g, "/").match(/\/(llama\.cpp-[^/]+)\//i);
   if (llamaMatch) {
-    const d = join26(enginesRoot, llamaMatch[1]);
+    const d = join28(enginesRoot, llamaMatch[1]);
     return inside(d) ? d : null;
   }
   return null;
@@ -16340,7 +16857,7 @@ function cleanModelName(p) {
 function readTail2(path, n) {
   if (!path || !existsSync22(path)) return [];
   try {
-    const lines = readFileSync11(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
+    const lines = readFileSync14(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
     return lines.length > n ? lines.slice(-n) : lines;
   } catch {
     return [];
@@ -16530,7 +17047,7 @@ function buildConnectSnippets(cli, base2, apiKey, modelName, modelKey = modelNam
 }
 
 // src/chat/chat-agent-routes.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function err4(c, status, code, message) {
   return c.json({ error: { code, message } }, status);
 }
@@ -16580,7 +17097,7 @@ function registerChatAgentRoutes(app2, d) {
       return err4(c, 400, "too_many_agents", `Agent limit reached (${AGENT_CAP}).`);
     }
     const agent = {
-      id: randomUUID8(),
+      id: randomUUID9(),
       name: b.name.trim(),
       description: b.description?.trim() ?? "",
       systemPrompt: b.systemPrompt ?? "",
@@ -16744,7 +17261,7 @@ import { streamSSE as streamSSE3 } from "hono/streaming";
 import { EventEmitter as EventEmitter2 } from "events";
 
 // src/code/code-session.ts
-import { join as join29, resolve as resolve3 } from "path";
+import { join as join31, resolve as resolve3 } from "path";
 import { readFile as readFile2 } from "fs/promises";
 import { Type, Unsafe } from "typebox";
 import {
@@ -16973,7 +17490,7 @@ Cannot execute bash commands.`);
 
 // src/code/containment.ts
 import { realpathSync as realpathSync2 } from "fs";
-import { resolve as resolve2, dirname as dirname10, basename as basename4, join as join27, sep } from "path";
+import { resolve as resolve2, dirname as dirname10, basename as basename4, join as join29, sep } from "path";
 var isWin = process.platform === "win32";
 function canonicalize(input) {
   if (typeof input !== "string" || input.length === 0) return null;
@@ -16989,7 +17506,7 @@ function canonicalize(input) {
   for (let i = 0; i < 4096; i++) {
     try {
       const real = realpathSync2(cur);
-      const full = tail.length ? join27(real, ...[...tail].reverse()) : real;
+      const full = tail.length ? join29(real, ...[...tail].reverse()) : real;
       return normForCompare(full);
     } catch {
       const parent = dirname10(cur);
@@ -17032,8 +17549,8 @@ function isContainedFromRoot(input, root) {
 }
 
 // src/code/persona.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { join as join28 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join30 } from "path";
 var MAX_SKILL_CATALOG_CHARS = 16e3;
 var MAX_AGENTS_MD_CHARS = 2e4;
 var MAX_AGENTS_MD_CANDIDATES = 8;
@@ -17151,7 +17668,7 @@ function skillCatalogBlock(skills) {
 }
 function readAgentsFile(path) {
   try {
-    const text = readFileSync12(path, "utf8").trim();
+    const text = readFileSync15(path, "utf8").trim();
     if (!text) return null;
     return text.length > MAX_AGENTS_MD_CHARS ? text.slice(0, MAX_AGENTS_MD_CHARS) : text;
   } catch {
@@ -17161,7 +17678,7 @@ function readAgentsFile(path) {
 function resolveAgentsFile(root, candidates) {
   for (const entry of candidates.slice(0, MAX_AGENTS_MD_CANDIDATES)) {
     if (!isContainedFromRoot(entry, root)) continue;
-    const text = readAgentsFile(join28(root, entry));
+    const text = readAgentsFile(join30(root, entry));
     if (text !== null) return { name: entry, text };
   }
   return null;
@@ -17692,7 +18209,7 @@ async function runCodeSession(params) {
     console.warn(`[code-session] history seed for session ${sessionId} produced ${sessionManager.getEntries().length}/${expectedEntries} expected entries \u2014 falling back to a plain-text history prefix on this turn's prompt`);
     task = `${HISTORY_FALLBACK_PREFIX}${renderHistoryFallbackText(summaryText, priorMessages)}${HISTORY_FALLBACK_SUFFIX}${rawTask}`;
   }
-  const agentDir = join29(d.store.dir(), "pi-agent");
+  const agentDir = join31(d.store.dir(), "pi-agent");
   modelRegistry.registerProvider("local", {
     baseUrl: `${target}/v1`,
     apiKey: "agent-key",
@@ -17823,7 +18340,7 @@ async function runCodeSession(params) {
         await sink({ event: "tool_call", data });
       });
     };
-    const skillAgentDir = join29(d.store.dir(), "pi-agent");
+    const skillAgentDir = join31(d.store.dir(), "pi-agent");
     const skillResourceLoader = new DefaultResourceLoader({
       cwd: repoRoot,
       agentDir: skillAgentDir,
@@ -17966,7 +18483,7 @@ async function runCodeSession(params) {
         await sink({ event: "tool_call", data });
       });
     };
-    const subAgentDir = join29(d.store.dir(), "pi-agent");
+    const subAgentDir = join31(d.store.dir(), "pi-agent");
     const subResourceLoader = new DefaultResourceLoader({
       cwd: repoRoot,
       agentDir: subAgentDir,
@@ -18524,7 +19041,7 @@ async function compactCodeSession(params) {
       return payload;
     });
   };
-  const compactAgentDir = join29(d.store.dir(), "pi-agent");
+  const compactAgentDir = join31(d.store.dir(), "pi-agent");
   const compactResourceLoader = new DefaultResourceLoader({
     cwd: repoRoot,
     agentDir: compactAgentDir,
@@ -18626,7 +19143,7 @@ async function lookbackPreCompactionHistory(params) {
       return payload;
     });
   };
-  const lookbackAgentDir = join29(d.store.dir(), "pi-agent");
+  const lookbackAgentDir = join31(d.store.dir(), "pi-agent");
   const lookbackResourceLoader = new DefaultResourceLoader({
     cwd: repoRoot,
     agentDir: lookbackAgentDir,
@@ -19073,7 +19590,7 @@ function subscribeToBuffer(buffer, emitter, opts) {
 }
 
 // src/code/revert.ts
-import { existsSync as existsSync23, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync15 } from "fs";
 import { resolve as resolve4 } from "path";
 import { applyPatch, parsePatch, reversePatch } from "diff";
 function revertFileEdits(messages, repoRoot) {
@@ -19102,7 +19619,7 @@ function revertFileEdits(messages, repoRoot) {
     }
     let content;
     try {
-      content = readFileSync13(absPath, "utf8");
+      content = readFileSync16(absPath, "utf8");
     } catch {
       failed.push(path);
       continue;
@@ -19131,7 +19648,7 @@ function revertFileEdits(messages, repoRoot) {
       continue;
     }
     try {
-      writeFileSync13(absPath, content);
+      writeFileSync15(absPath, content);
       reverted.push(path);
     } catch {
       failed.push(path);
@@ -19899,11 +20416,11 @@ function registerCodeRoutes(app2, d) {
 }
 
 // src/gateway/gateway.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { streamSSE as streamSSE4 } from "hono/streaming";
 
 // src/gateway/anthropic.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 var UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
   "format",
   "pattern",
@@ -20072,7 +20589,7 @@ function mapFromOpenAI(oai, modelName) {
   }
   const usage = oai.usage;
   return {
-    id: `msg_${randomUUID9().replace(/-/g, "")}`,
+    id: `msg_${randomUUID10().replace(/-/g, "")}`,
     type: "message",
     role: "assistant",
     model: modelName,
@@ -20368,7 +20885,7 @@ function registerGateway(app2, d) {
       );
     }
     if (req.stream) {
-      const msgId = `msg_${randomUUID10().replace(/-/g, "")}`;
+      const msgId = `msg_${randomUUID11().replace(/-/g, "")}`;
       const gen = streamToAnthropic(
         res.body,
         modelName,
@@ -20640,9 +21157,28 @@ async function recordOpenAiStreamUsage(d, body7, source, modelKey, codeSessionId
   }
 }
 
+// src/telemetry/feature-map.ts
+var BY_SEGMENT = {
+  chat: "chat",
+  code: "code",
+  artifacts: "artifacts",
+  mcp: "mcp",
+  bench: "autotune",
+  // Covers install/uninstall (explicit user setup) AND acquire/release (pushed
+  // by ComfyUI's OWN gate node when an actual generation runs, not polled by
+  // our UI) — unlike skills/chat-agents, every hit here is real image-gen
+  // activity, not a side effect of an unrelated screen loading.
+  comfyui: "image"
+};
+function featureForPath(path) {
+  const m = /^\/api\/v1\/([^/?]+)/.exec(path);
+  if (m === null) return null;
+  return BY_SEGMENT[m[1]] ?? null;
+}
+
 // src/server.ts
 setGlobalDispatcher(new Agent({ keepAliveMaxTimeout: 6e4, connections: 10 }));
-var WEB_ROOT = join30(dirname11(fileURLToPath(import.meta.url)), "webdist");
+var WEB_ROOT = join32(dirname11(fileURLToPath(import.meta.url)), "webdist");
 function createApp(d) {
   const app2 = new Hono();
   app2.use(
@@ -20667,6 +21203,11 @@ function createApp(d) {
   });
   app2.use("*", lanAuth(d));
   app2.use("/api/v1/code/*", codeAuth(d));
+  app2.use("*", async (c, next) => {
+    const feature = d.telemetry ? featureForPath(c.req.path) : null;
+    if (feature !== null) d.telemetry?.firstUse(feature);
+    await next();
+  });
   app2.get("/healthz", (c) => c.json({ status: "ok", version: d.version }));
   registerApi(app2, d);
   registerChatRoutes(app2, d);
@@ -20680,12 +21221,12 @@ function createApp(d) {
     if (path.startsWith("api/") || path.startsWith("v1/")) {
       return c.json({ error: { code: "not_found", message: "Unknown endpoint." } }, 404);
     }
-    let file = normalize2(join30(WEB_ROOT, path || "index.html"));
+    let file = normalize2(join32(WEB_ROOT, path || "index.html"));
     if (!file.startsWith(WEB_ROOT) || !existsSync24(file) || statSync6(file).isDirectory()) {
-      file = join30(WEB_ROOT, "index.html");
+      file = join32(WEB_ROOT, "index.html");
     }
     if (!existsSync24(file)) return c.text("web ui not built \u2014 run `npm run build:web`", 500);
-    return new Response(readFileSync14(file), { status: 200, headers: { "Content-Type": contentType(file) } });
+    return new Response(readFileSync17(file), { status: 200, headers: { "Content-Type": contentType(file) } });
   });
   return app2;
 }
@@ -20711,21 +21252,21 @@ function contentType(file) {
 
 // src/tunnel/manager.ts
 import { execFile as execFile13, spawn as spawn7, spawnSync as spawnSync3 } from "child_process";
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync15, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync14 } from "fs";
-import { join as join32 } from "path";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync18, readdirSync as readdirSync11, rmSync as rmSync16, writeFileSync as writeFileSync16 } from "fs";
+import { join as join34 } from "path";
 
 // src/tunnel/provision.ts
-import { chmodSync as chmodSync3, existsSync as existsSync25, mkdirSync as mkdirSync15, rmSync as rmSync14 } from "fs";
-import { join as join31 } from "path";
+import { chmodSync as chmodSync3, existsSync as existsSync25, mkdirSync as mkdirSync17, rmSync as rmSync15 } from "fs";
+import { join as join33 } from "path";
 var CLOUDFLARED_REPO = "cloudflare/cloudflared";
 function cloudflaredDir(dataDir) {
-  return join31(dataDir, "cloudflared");
+  return join33(dataDir, "cloudflared");
 }
 function cloudflaredBinName(platform = process.platform) {
   return platform === "win32" ? "cloudflared.exe" : "cloudflared";
 }
 function cloudflaredBinPath(dataDir, platform = process.platform) {
-  return join31(cloudflaredDir(dataDir), cloudflaredBinName(platform));
+  return join33(cloudflaredDir(dataDir), cloudflaredBinName(platform));
 }
 function cloudflaredAssetName(platform = process.platform, archStr = process.arch) {
   if (platform === "win32") {
@@ -20754,18 +21295,18 @@ async function ensureCloudflared(dataDir, onProgress, signal) {
   if (existsSync25(binPath)) return { binPath, version: version2 };
   const asset = pickCloudflaredAsset(rel.assets ?? []);
   if (!asset) throw new Error("no_release_asset");
-  mkdirSync15(dir, { recursive: true });
+  mkdirSync17(dir, { recursive: true });
   onProgress?.({ phase: "downloading", pct: 0 });
   if (asset.name.endsWith(".tgz")) {
-    const tmp = join31(dir, asset.name);
+    const tmp = join33(dir, asset.name);
     try {
       await downloadFile(asset.browser_download_url, tmp, onProgress, signal);
       onProgress?.({ phase: "extracting", pct: -1 });
       await extractArchive(tmp, dir);
-      rmSync14(tmp, { force: true });
+      rmSync15(tmp, { force: true });
     } catch (e) {
-      rmSync14(tmp, { force: true });
-      rmSync14(dir, { recursive: true, force: true });
+      rmSync15(tmp, { force: true });
+      rmSync15(dir, { recursive: true, force: true });
       throw e;
     }
     const found = findFile(dir, "cloudflared");
@@ -20801,21 +21342,21 @@ function forceKill2(child) {
   else child.kill("SIGKILL");
 }
 function tunnelPidDir(dataDir) {
-  return join32(dataDir, "run");
+  return join34(dataDir, "run");
 }
 function tunnelPidFile(dataDir, pid) {
-  return join32(tunnelPidDir(dataDir), `tunnel-${pid}.pid`);
+  return join34(tunnelPidDir(dataDir), `tunnel-${pid}.pid`);
 }
 function writeTunnelPid(dataDir, pid) {
   try {
-    mkdirSync16(tunnelPidDir(dataDir), { recursive: true });
-    writeFileSync14(tunnelPidFile(dataDir, pid), JSON.stringify({ pid, owner: process.pid }));
+    mkdirSync18(tunnelPidDir(dataDir), { recursive: true });
+    writeFileSync16(tunnelPidFile(dataDir, pid), JSON.stringify({ pid, owner: process.pid }));
   } catch {
   }
 }
 function clearTunnelPid(dataDir, pid) {
   try {
-    rmSync15(tunnelPidFile(dataDir, pid), { force: true });
+    rmSync16(tunnelPidFile(dataDir, pid), { force: true });
   } catch {
   }
 }
@@ -20832,20 +21373,20 @@ function readTunnelPidFiles(dataDir) {
   const dir = tunnelPidDir(dataDir);
   let names;
   try {
-    names = readdirSync10(dir).filter((n) => /^tunnel-\d+\.pid$/.test(n));
+    names = readdirSync11(dir).filter((n) => /^tunnel-\d+\.pid$/.test(n));
   } catch {
     return [];
   }
   const out = [];
   for (const name of names) {
-    const file = join32(dir, name);
+    const file = join34(dir, name);
     try {
-      const { pid, owner } = JSON.parse(readFileSync15(file, "utf8"));
+      const { pid, owner } = JSON.parse(readFileSync18(file, "utf8"));
       if (typeof pid === "number" && pid > 0) out.push({ pid, owner: typeof owner === "number" ? owner : 0, file });
-      else rmSync15(file, { force: true });
+      else rmSync16(file, { force: true });
     } catch {
       try {
-        rmSync15(file, { force: true });
+        rmSync16(file, { force: true });
       } catch {
       }
     }
@@ -20863,7 +21404,7 @@ function reapStaleTunnels(dataDir) {
     } catch {
     }
     try {
-      rmSync15(file, { force: true });
+      rmSync16(file, { force: true });
     } catch {
     }
   }
@@ -20878,7 +21419,7 @@ function killTrackedTunnelsSync(dataDir) {
     } catch {
     }
     try {
-      rmSync15(file, { force: true });
+      rmSync16(file, { force: true });
     } catch {
     }
   }
@@ -20967,12 +21508,94 @@ var TunnelManager = class {
   }
 };
 
+// src/telemetry/emit.ts
+import { randomUUID as randomUUID12 } from "crypto";
+var REQUIRES_FULL = /* @__PURE__ */ new Set(["error"]);
+var Emitter = class {
+  o;
+  today;
+  constructor(opts) {
+    this.o = opts;
+    this.today = opts.today ?? (() => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10));
+  }
+  /**
+   * Whether this event may be sent right now — kill switch, consent level, and
+   * the per-event level requirement.
+   *
+   * Public because the once-only helpers MUST consult it before spending a
+   * ledger claim. Claiming first would mean a user who browses the app before
+   * answering the consent card burns every `first_use` key while telemetry is
+   * off, and opting in afterwards would permanently lose the whole
+   * feature-discovery picture — the exact data this system exists to collect.
+   */
+  canSend(event) {
+    if (telemetryDisabled()) return false;
+    const level = this.o.store.snapshot().telemetry.level;
+    if (level !== "anon" && level !== "full") return false;
+    if (REQUIRES_FULL.has(event) && level !== "full") return false;
+    return true;
+  }
+  /** Emit one event. Silently does nothing whenever it must not send. */
+  emit(event, payload) {
+    try {
+      if (!this.canSend(event)) return;
+      enqueue(this.o.dataDir, {
+        schema: TELEMETRY_SCHEMA_VERSION,
+        event,
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        machineId: this.machineId(),
+        app: { version: this.o.version, os: this.o.os },
+        ...payload === void 0 ? {} : { payload }
+      });
+    } catch {
+    }
+  }
+  /** Emit an event at most once for the lifetime of this install (e.g.
+   *  `app_first_run`, which must count installs — not daemon starts). */
+  once(event) {
+    if (!this.canSend(event)) return;
+    if (this.claim(`once:${event}`)) this.emit(event);
+  }
+  /** Emit `feature_first_use` the first time a feature is touched, ever. */
+  firstUse(feature) {
+    if (!this.canSend("feature_first_use")) return;
+    if (this.claim(`first_use:${feature}`)) this.emit("feature_first_use", { feature });
+  }
+  /** Emit `daily_active` at most once per calendar day. */
+  dailyActive() {
+    if (!this.canSend("daily_active")) return;
+    if (this.claim(`daily:${this.today()}`)) this.emit("daily_active");
+  }
+  /**
+   * Mint the anonymous machine id lazily.
+   *
+   * Never called while consent is off, because `emit` returns before this
+   * point — an install that never opts in must not even have an id generated
+   * for it.
+   */
+  machineId() {
+    const existing = this.o.store.snapshot().telemetry.machineId;
+    if (existing) return existing;
+    const id = randomUUID12();
+    this.o.store.update((c) => {
+      if (!c.telemetry.machineId) c.telemetry.machineId = id;
+    });
+    return id;
+  }
+  /** Record a once-only key. Returns whether THIS call claimed it (i.e. whether
+   *  the caller should go on to emit). Shared with the consent ping so both
+   *  agree on what "once" means. */
+  claim(key) {
+    return claimOnce(this.o.dataDir, key);
+  }
+};
+
 // src/cli.ts
 hideChildConsoleWindows();
 var version = "0.1.1";
 try {
-  const pkgPath = join33(dirname12(fileURLToPath2(import.meta.url)), "..", "package.json");
-  version = JSON.parse(readFileSync16(pkgPath, "utf8")).version ?? version;
+  const pkgPath = join35(dirname12(fileURLToPath2(import.meta.url)), "..", "package.json");
+  version = JSON.parse(readFileSync19(pkgPath, "utf8")).version ?? version;
 } catch {
 }
 var [nodeMajor, nodeMinor] = process.versions.node.split(".").map(Number);
@@ -20997,9 +21620,10 @@ function argValue(name, fallback) {
   const i = process.argv.indexOf(name);
   return i >= 0 && i + 1 < process.argv.length ? process.argv[i + 1] : fallback;
 }
+if (hasFlag("--no-telemetry")) process.env[TELEMETRY_ENV] = "off";
 function configuredDaemonPort(configPath) {
   try {
-    const cfg2 = JSON.parse(readFileSync16(configPath, "utf8"));
+    const cfg2 = JSON.parse(readFileSync19(configPath, "utf8"));
     if (typeof cfg2.daemon?.port === "number" && cfg2.daemon.port > 0) return cfg2.daemon.port;
   } catch {
   }
@@ -21073,6 +21697,9 @@ Options:
                  tunnel (Cloud Launch) \u2014 prints the public URL + a required
                  access token. For running TurboLLM on a rented cloud GPU box.
   --config <f>   Path to a custom config file
+  --no-telemetry Disable telemetry entirely, whatever this install's saved
+                 setting says (same as TURBOLLM_TELEMETRY=off). For CI,
+                 containers, and scripted daemons.
   --stop         Stop a running TurboLLM daemon and exit
   --help, -h     Show this help message
 
@@ -21119,7 +21746,7 @@ if (pruned > 0) console.log(`pruned ${pruned} dangling engine build(s)`);
 var provision = new ProvisionState();
 var build = new BuildState();
 var updates = new UpdateChecker();
-var enginesDir = join33(store.dir(), "engines");
+var enginesDir = join35(store.dir(), "engines");
 void seedDefaultEngines(registry, enginesDir, provision).then(() => registry.ensureProbed());
 var manager = new Manager(store);
 var scanner = new Scanner(store);
@@ -21148,6 +21775,19 @@ var appUpdates = new AppUpdateChecker(version);
 var deps = { store, registry, manager, scanner, hashes, db, provision, build, updates, appUpdates, hf, downloads, bench, modelRouter, comfy, tools: toolRegistry, version, startedAt };
 deps.gate = new GenerationGate();
 deps.agentTasks = new AgentTaskState();
+var telemetry = new Emitter({ dataDir: store.dir(), store, version, os: getSysInfo().os });
+deps.telemetry = telemetry;
+telemetry.dailyActive();
+manager.onLoadSettled = (ok, err7) => reportModelLoad(store.dir(), telemetry, ok ? "ok" : "fail", ok ? void 0 : classifyLoadFailure(err7));
+bench.telemetry = telemetry;
+build.onSettled = (ok) => telemetry.emit("onboarding_step", { step: "engine_build", outcome: ok ? "ok" : "fail" });
+provision.onSettled = (ok) => telemetry.emit("onboarding_step", { step: "engine_install", outcome: ok ? "ok" : "fail" });
+downloads.onSettled = (outcome) => telemetry.emit("onboarding_step", { step: "model_download", outcome });
+setTimeout(() => {
+  telemetry.once("app_first_run");
+  void flush(store.dir(), store.snapshot().telemetry.level);
+}, 3e3).unref();
+setInterval(() => void flush(store.dir(), store.snapshot().telemetry.level), 5 * 6e4).unref();
 var tunnelRequested = hasFlag("--tunnel");
 if (tunnelRequested) deps.tunnel = new TunnelManager(store.dir());
 var app = createApp(deps);
@@ -21293,7 +21933,7 @@ var restarting = false;
 function spawnReplacement() {
   let out = "ignore";
   try {
-    out = openSync3(join33(store.dir(), "restart.log"), "a");
+    out = openSync3(join35(store.dir(), "restart.log"), "a");
   } catch {
     out = "ignore";
   }