rigscope 0.2.0 → 0.2.1

package/dist/cli.cjs

@@ -23,8 +23,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli/main.ts
-var import_node_fs19 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path21 = require("node:path");
 var import_node_util2 = require("node:util");
 var import_node_readline = require("node:readline");
 var import_node_stream = require("node:stream");
@@ -42,6 +42,9 @@ var SHARING_KEYS = [
   "processArguments"
 ];
 
+// collector/destinations/queue.ts
+var DEFAULT_COLLECTOR_QUEUE_MODE = "memory";
+
 // collector/config.ts
 var ConfigError = class extends Error {
   issues;
@@ -247,6 +250,18 @@ function parseDestinations(env, issues, destinations) {
     }
   }
 }
+var QUEUE_MODES = ["memory", "durable"];
+function parseQueueMode(env, issues) {
+  const raw = env["COLLECTOR_QUEUE_MODE"]?.trim();
+  if (raw === void 0 || raw === "") {
+    return DEFAULT_COLLECTOR_QUEUE_MODE;
+  }
+  if (!QUEUE_MODES.includes(raw)) {
+    issues.push(`COLLECTOR_QUEUE_MODE must be one of ${QUEUE_MODES.join(" or ")}`);
+    return DEFAULT_COLLECTOR_QUEUE_MODE;
+  }
+  return raw;
+}
 function parseIntervalMs(env, issues) {
   const raw = env["COLLECTOR_INTERVAL_MS"]?.trim();
   if (raw === void 0 || raw === "") {
@@ -277,6 +292,7 @@ function parseCollectorConfig(env) {
   }
   const destinations = [];
   const intervalMs = parseIntervalMs(env, issues);
+  const queueMode = parseQueueMode(env, issues);
   parseDestinations(env, issues, destinations);
   if (issues.length > 0) {
     throw new ConfigError(issues);
@@ -286,7 +302,8 @@ function parseCollectorConfig(env) {
     hostname,
     hostnameIsMockDefault: rawHostname === "",
     intervalMs,
-    destinations
+    destinations,
+    queueMode
   };
 }
 
@@ -3624,17 +3641,17 @@ function uninstallInstallation(dir, purge = true, injected = {}) {
 
 // src/cli/mutation.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs13 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path15 = require("node:path");
 var import_promises = require("node:readline/promises");
 
 // src/cli/lifecycle.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path14 = require("node:path");
 
 // src/cli/upgrade.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path13 = require("node:path");
 
 // src/operations/database.ts
 var import_node_fs10 = require("node:fs");
@@ -3982,6 +3999,187 @@ async function restoreDatabase(options) {
     throw error2;
   }
 }
+var MACHINE_HISTORY_TABLES = [
+  "points_raw",
+  "points_10s",
+  "points_1m",
+  "points_1h",
+  "sample_receipts",
+  "gaps",
+  "machine_latest",
+  "inventory",
+  "alert_observed_resources",
+  "alert_machine_progress",
+  "alert_incidents",
+  "series"
+];
+function clearMachineHistory(database) {
+  const path2 = resolvePath(database, "database");
+  if (!(0, import_node_fs10.existsSync)(path2)) return { deleted: {}, integrity: "absent" };
+  assertPrivateRegularFile(path2, "database");
+  assertNoActiveHubLock(path2);
+  const db = new import_node_sqlite2.DatabaseSync(path2, { timeout: BUSY_TIMEOUT_MS2 });
+  const deleted = {};
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    const present = new Set(
+      db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name)
+    );
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const table of MACHINE_HISTORY_TABLES) {
+        if (!present.has(table)) continue;
+        const result = db.prepare(`DELETE FROM ${table}`).run();
+        deleted[table] = Number(result.changes);
+      }
+      db.exec("COMMIT");
+    } catch (error2) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error2;
+    }
+    const autoVacuum = db.prepare("PRAGMA auto_vacuum").get();
+    if (autoVacuum && Object.values(autoVacuum)[0] === 2) db.exec("PRAGMA incremental_vacuum(1024)");
+    try {
+      db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    } catch {
+    }
+  } finally {
+    db.close();
+  }
+  return { deleted, integrity: inspectDatabase(path2).integrity };
+}
+
+// src/cli/machine-transition.ts
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = require("node:path");
+var import_node_crypto11 = require("node:crypto");
+var MACHINE_DATA_TRANSITION_FILE = "machine-data-transition.json";
+var STAGED_QUEUE_PREFIX = "outbox.pre-transition-";
+function machineDataTransitionPath(stateRoot) {
+  return (0, import_node_path12.join)(stateRoot, MACHINE_DATA_TRANSITION_FILE);
+}
+function readMachineDataTransition(stateRoot) {
+  const path2 = machineDataTransitionPath(stateRoot);
+  try {
+    const stat = (0, import_node_fs11.lstatSync)(path2);
+    if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 63) !== 0) {
+      throw new Error("marker must be a private regular file");
+    }
+    const value = JSON.parse((0, import_node_fs11.readFileSync)(path2, "utf8"));
+    if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid marker");
+    const record = value;
+    if (typeof record.transitionedAt !== "string" || !Number.isFinite(Date.parse(record.transitionedAt))) {
+      throw new Error("invalid transition date");
+    }
+    return { transitionedAt: record.transitionedAt, release: typeof record.release === "string" ? record.release : null };
+  } catch (error2) {
+    if (error2.code === "ENOENT") return null;
+    throw new OperationsError(
+      "invalid-transition-marker",
+      `Cannot determine whether the one-time reset completed; preserving machine data. Repair ${path2}: ${errorMessage(error2)}`,
+      { cause: error2 }
+    );
+  }
+}
+function recordMachineDataTransition(stateRoot, release, write = (path2, content) => writePrivateFile(path2, content)) {
+  const marker = { transitionedAt: (/* @__PURE__ */ new Date()).toISOString(), release };
+  write(machineDataTransitionPath(stateRoot), `${JSON.stringify(marker, null, 2)}
+`);
+}
+function newMachineDataCleanup(transitioned) {
+  return {
+    report: { transitioned, databaseRows: null, collectorQueuesRemoved: false, warning: null },
+    stagedQueues: null,
+    databaseCleared: false
+  };
+}
+function performMachineDataCleanup(stateRoot, paths, now = Date.now, deps = {}) {
+  if (readMachineDataTransition(stateRoot) !== null) return newMachineDataCleanup(false);
+  const cleanup = newMachineDataCleanup(true);
+  const clear = deps.clear ?? clearMachineHistory;
+  const warnings = [];
+  try {
+    if ((0, import_node_fs11.existsSync)(paths.queueTree)) {
+      const staged = (0, import_node_path12.join)((0, import_node_path12.dirname)(paths.queueTree), `${STAGED_QUEUE_PREFIX}${timestampSlug(now())}-${(0, import_node_crypto11.randomUUID)()}`);
+      (0, import_node_fs11.renameSync)(paths.queueTree, staged);
+      cleanup.stagedQueues = staged;
+      cleanup.report.collectorQueuesRemoved = true;
+    }
+  } catch (error2) {
+    warnings.push(`collector queues: ${errorMessage(error2)}`);
+  }
+  try {
+    if ((0, import_node_fs11.existsSync)(paths.database)) {
+      cleanup.databaseCleared = true;
+      cleanup.report.databaseRows = clear(paths.database).deleted;
+    }
+  } catch (error2) {
+    warnings.push(`hub database: ${errorMessage(error2)}`);
+  }
+  cleanup.report.warning = warnings.length > 0 ? warnings.join("; ") : null;
+  return cleanup;
+}
+function undoMachineDataCleanup(paths, stagedQueues) {
+  if (stagedQueues === null || !(0, import_node_fs11.existsSync)(stagedQueues)) return [];
+  try {
+    if ((0, import_node_fs11.existsSync)(paths.queueTree)) {
+      const failedQueue = `${paths.queueTree}.failed-transition-${(0, import_node_crypto11.randomUUID)()}`;
+      (0, import_node_fs11.renameSync)(paths.queueTree, failedQueue);
+      try {
+        (0, import_node_fs11.renameSync)(stagedQueues, paths.queueTree);
+      } catch (error2) {
+        (0, import_node_fs11.renameSync)(failedQueue, paths.queueTree);
+        throw error2;
+      }
+      return [`restored the collector queue tree; replacement runtime queue preserved at ${failedQueue}`];
+    }
+    (0, import_node_fs11.renameSync)(stagedQueues, paths.queueTree);
+    return ["restored the collector queue tree the transition had staged aside"];
+  } catch (error2) {
+    return [`machine data rollback could not restore the collector queue: ${errorMessage(error2)}`];
+  }
+}
+function completeMachineDataCleanup(stateRoot, cleanup, release, write) {
+  if (!cleanup.report.transitioned) return;
+  if (cleanup.report.warning !== null) return;
+  try {
+    recordMachineDataTransition(stateRoot, release, write);
+  } catch (error2) {
+    cleanup.report.warning = `could not record transition completion: ${errorMessage(error2)}`;
+    return;
+  }
+  if (cleanup.stagedQueues !== null) {
+    try {
+      (0, import_node_fs11.rmSync)(cleanup.stagedQueues, { recursive: true, force: true });
+    } catch (error2) {
+      cleanup.report.warning = `transition completed; staged queue remains at ${cleanup.stagedQueues}: ${errorMessage(error2)}`;
+    }
+  }
+}
+function machineDataReportRows(report) {
+  if (report.databaseRows === null) return null;
+  return Object.values(report.databaseRows).reduce((sum, rows) => sum + rows, 0);
+}
+function machineDataKeptNote() {
+  return "accounts, sessions, enrollment and grants, settings, alert rules/jobs/webhook settings, machine names/tags and recordings were kept";
+}
+function describeMachineDataReport(report) {
+  const summary = report.transitioned ? (() => {
+    const rows = machineDataReportRows(report);
+    const parts = [
+      rows === null ? "no hub database" : `${rows} database row(s)`,
+      ...report.collectorQueuesRemoved ? ["the collector queue tree"] : []
+    ];
+    return `Machine data: one-time RAM-first transition discarded ${parts.join(" and ")}. The ${machineDataKeptNote()}.`;
+  })() : "Machine data: one-time transition already completed; durable history and collector queues preserved.";
+  return {
+    summary,
+    warning: report.warning === null ? null : `Machine-data cleanup warning (${report.warning}). The upgrade is healthy; cleanup without a completion marker is retried on the next upgrade.`
+  };
+}
 
 // src/cli/health.ts
 var import_node_http2 = require("node:http");
@@ -4175,6 +4373,7 @@ function dependencies(deps = {}) {
     restore: deps.restore ?? restoreDatabase,
     inspect: deps.inspect ?? inspectDatabase,
     inspectRuntime: deps.inspectRuntime ?? inspectDatabaseWithRuntime,
+    clearHistory: deps.clearHistory ?? clearMachineHistory,
     waitHealth: deps.waitHealth ?? waitForHealth,
     activate: deps.activate ?? activatePackage,
     swap: deps.swap ?? swapRuntimes,
@@ -4185,10 +4384,10 @@ function dependencies(deps = {}) {
 function acquireInstallLocks(dir, acquireLease) {
   const releases = [];
   try {
-    releases.push(acquireLease((0, import_node_path12.join)(dir, "run", "hub.lock")));
-    releases.push(acquireLease((0, import_node_path12.join)(dir, "run", "collector.lock")));
-    releases.push(acquireLease((0, import_node_path12.join)(dir, "run", "rigscope.lock")));
-    releases.push(acquireLease((0, import_node_path12.join)(dir, "collector", "collector-runtime.lock")));
+    releases.push(acquireLease((0, import_node_path13.join)(dir, "run", "hub.lock")));
+    releases.push(acquireLease((0, import_node_path13.join)(dir, "run", "collector.lock")));
+    releases.push(acquireLease((0, import_node_path13.join)(dir, "run", "rigscope.lock")));
+    releases.push(acquireLease((0, import_node_path13.join)(dir, "collector", "collector-runtime.lock")));
   } catch (error2) {
     for (const release of releases.reverse()) {
       try {
@@ -4254,8 +4453,11 @@ function assertComponentsStopped(dir, deps, components) {
     }
   }
 }
+function machineDataPaths(dir) {
+  return { database: databasePath(dir), queueTree: (0, import_node_path13.join)(dir, "collector", "outbox") };
+}
 function collectorStateCheck(dir) {
-  const path2 = (0, import_node_path12.join)(dir, "collector", "state.json");
+  const path2 = (0, import_node_path13.join)(dir, "collector", "state.json");
   let raw;
   try {
     raw = readPrivate(path2);
@@ -4279,13 +4481,13 @@ function hubTarget(config, dir) {
     role: "hub",
     port: config.port,
     origin: config.origin,
-    socket: config.socket ?? (0, import_node_path12.join)(dir, "run", "hub.sock")
+    socket: config.socket ?? (0, import_node_path13.join)(dir, "run", "hub.sock")
   });
 }
 async function verifyRunningInstallation(options) {
   const d = dependencies(options.deps);
   const deadline = Date.now() + (options.deadlineMs ?? DEFAULT_HEALTH_DEADLINE_MS);
-  const runtime = (0, import_node_path12.join)(options.dir, "runtime");
+  const runtime = (0, import_node_path13.join)(options.dir, "runtime");
   const version = runtimeVersion(runtime);
   if (version !== options.expectedVersion) {
     throw new OperationsError(
@@ -4326,7 +4528,7 @@ async function verifyRunningInstallation(options) {
       }
     }
     const path2 = databasePath(options.dir);
-    if (!(0, import_node_fs11.existsSync)(path2)) {
+    if (!(0, import_node_fs12.existsSync)(path2)) {
       if (status.active) {
         throw new OperationsError("database-missing", `hub database is missing after activation: ${path2}`);
       }
@@ -4366,8 +4568,8 @@ async function verifyRunningInstallation(options) {
       let problem = "collector has not sampled";
       while (Date.now() < deadline) {
         try {
-          const marker = JSON.parse(readPrivate((0, import_node_path12.join)(options.dir, "run", "collector-health.json")));
-          const owner = JSON.parse(readPrivate((0, import_node_path12.join)(options.dir, "collector", "collector-runtime.lock")));
+          const marker = JSON.parse(readPrivate((0, import_node_path13.join)(options.dir, "run", "collector-health.json")));
+          const owner = JSON.parse(readPrivate((0, import_node_path13.join)(options.dir, "collector", "collector-runtime.lock")));
           if (marker.version !== options.expectedVersion) throw new Error("collector version does not match the activated release");
           if (marker.pid !== owner.pid || !Number.isSafeInteger(marker.pid)) throw new Error("collector readiness belongs to another process");
           process.kill(marker.pid, 0);
@@ -4385,7 +4587,7 @@ async function verifyRunningInstallation(options) {
   return { version, health, database };
 }
 async function recoverActivation(options) {
-  const runtime = (0, import_node_path12.join)(options.dir, "runtime");
+  const runtime = (0, import_node_path13.join)(options.dir, "runtime");
   const messages = [];
   let releaseLocks = null;
   try {
@@ -4394,12 +4596,16 @@ async function recoverActivation(options) {
       if (status.active) options.deps.service.stop(options.dir, component);
     }
     assertComponentsStopped(options.dir, options.deps, COMPONENT_LIST);
-    if ((0, import_node_fs11.existsSync)(databasePath(options.dir))) assertNoActiveHubLock(databasePath(options.dir));
+    if ((0, import_node_fs12.existsSync)(databasePath(options.dir))) assertNoActiveHubLock(databasePath(options.dir));
     releaseLocks = acquireInstallLocks(options.dir, options.deps.acquireLease);
+    messages.push(...undoMachineDataCleanup(machineDataPaths(options.dir), options.machineData?.stagedQueues ?? null));
+    if (options.machineData?.report.warning) {
+      messages.push(`machine-data cleanup was incomplete: ${options.machineData.report.warning}`);
+    }
     if (options.activated) {
       try {
-        if ((0, import_node_fs11.existsSync)(runtime)) options.deps.swap(options.dir);
-        const restoredVersion = runtimeVersion((0, import_node_path12.join)(options.dir, "runtime"));
+        if ((0, import_node_fs12.existsSync)(runtime)) options.deps.swap(options.dir);
+        const restoredVersion = runtimeVersion((0, import_node_path13.join)(options.dir, "runtime"));
         if (restoredVersion !== options.previousVersion) {
           throw new Error(`restored runtime reports ${restoredVersion}, expected ${options.previousVersion}`);
         }
@@ -4410,10 +4616,11 @@ async function recoverActivation(options) {
       }
     }
     const path2 = databasePath(options.dir);
-    if (options.backupPath !== null && (0, import_node_fs11.existsSync)(options.backupPath) && (0, import_node_fs11.existsSync)(path2)) {
+    const transitionClearedHistory = options.machineData?.databaseCleared === true;
+    if (options.backupPath !== null && (0, import_node_fs12.existsSync)(options.backupPath) && (0, import_node_fs12.existsSync)(path2)) {
       try {
-        const old = options.deps.inspectRuntime((0, import_node_path12.join)(options.dir, "runtime"), path2);
-        if (!old.integrityOk || old.newerSchema || old.ledgerProblem !== null) {
+        const old = options.deps.inspectRuntime((0, import_node_path13.join)(options.dir, "runtime"), path2);
+        if (transitionClearedHistory || !old.integrityOk || old.newerSchema || old.ledgerProblem !== null) {
           const restored = await options.deps.restore({
             input: options.backupPath,
             database: path2,
@@ -4430,16 +4637,16 @@ async function recoverActivation(options) {
         messages.push(`database recovery failed: ${errorMessage(error2)}; pre-upgrade copy is ${options.backupPath}`);
         return messages.join("; ");
       }
-    } else if (options.backupPath === null && (0, import_node_fs11.existsSync)(path2)) {
+    } else if (options.backupPath === null && (0, import_node_fs12.existsSync)(path2)) {
       try {
-        const old = options.deps.inspectRuntime((0, import_node_path12.join)(options.dir, "runtime"), path2);
+        const old = options.deps.inspectRuntime((0, import_node_path13.join)(options.dir, "runtime"), path2);
         if (!old.integrityOk || old.newerSchema || old.ledgerProblem !== null) {
-          const backups = (0, import_node_path12.join)(options.dir, "backups");
+          const backups = (0, import_node_path13.join)(options.dir, "backups");
           ensurePrivateDir(backups);
-          const preserved = (0, import_node_path12.join)(backups, `failed-activation-${timestampSlug(options.deps.now())}.sqlite`);
-          (0, import_node_fs11.renameSync)(path2, preserved);
+          const preserved = (0, import_node_path13.join)(backups, `failed-activation-${timestampSlug(options.deps.now())}.sqlite`);
+          (0, import_node_fs12.renameSync)(path2, preserved);
           for (const sidecar of [`${path2}-wal`, `${path2}-shm`]) {
-            if ((0, import_node_fs11.existsSync)(sidecar)) (0, import_node_fs11.renameSync)(sidecar, `${preserved}${sidecar.slice(path2.length)}`);
+            if ((0, import_node_fs12.existsSync)(sidecar)) (0, import_node_fs12.renameSync)(sidecar, `${preserved}${sidecar.slice(path2.length)}`);
           }
           messages.push(`preserved the failed activation database at ${preserved}; the previous runtime will create a fresh database`);
         } else {
@@ -4483,8 +4690,8 @@ async function upgradeInstallation(options, injected = {}) {
   const deps = dependencies(injected);
   const config = readSetup(options.dir);
   if (!config) throw new OperationsError("not-installed", "No installation found. Run rigscope install first.");
-  const runtime = (0, import_node_path12.join)(options.dir, "runtime");
-  if (!(0, import_node_fs11.existsSync)(runtime)) {
+  const runtime = (0, import_node_path13.join)(options.dir, "runtime");
+  if (!(0, import_node_fs12.existsSync)(runtime)) {
     throw new OperationsError("not-installed", "Install a managed runtime before upgrading.");
   }
   const currentVersion = runtimeVersion(runtime);
@@ -4497,7 +4704,7 @@ async function upgradeInstallation(options, injected = {}) {
     expectedVersion = runtimeVersion(stage);
     assertRuntimeArtifacts(stage, "staged runtime");
     const path2 = databasePath(options.dir);
-    if ((0, import_node_fs11.existsSync)(path2)) {
+    if ((0, import_node_fs12.existsSync)(path2)) {
       const staged = deps.inspectRuntime(stage, path2);
       if (!staged.integrityOk) {
         throw new OperationsError("database-integrity", `database integrity check failed before upgrade: ${path2}`);
@@ -4514,26 +4721,27 @@ async function upgradeInstallation(options, injected = {}) {
       expectedSchema = staged.supportedSchemaVersion;
     }
   } catch (error2) {
-    (0, import_node_fs11.rmSync)(stage, { recursive: true, force: true });
+    (0, import_node_fs12.rmSync)(stage, { recursive: true, force: true });
     throw error2;
   }
   const snapshot = snapshotComponents(options.dir, deps);
   const running = snapshot.running;
   let releaseLocks = null;
-  const releaseOperation = deps.acquireLease((0, import_node_path12.join)(options.dir, "run", "operation.lock"));
+  const releaseOperation = deps.acquireLease((0, import_node_path13.join)(options.dir, "run", "operation.lock"));
   let backupPath = null;
   let activated = false;
+  let machineData = null;
   try {
     stopComponents(options.dir, deps, running);
     assertComponentsStopped(options.dir, deps, running);
-    if (running.includes("hub") || componentEnabled(config, "hub") || (0, import_node_fs11.existsSync)(databasePath(options.dir))) {
+    if (running.includes("hub") || componentEnabled(config, "hub") || (0, import_node_fs12.existsSync)(databasePath(options.dir))) {
       assertNoActiveHubLock(databasePath(options.dir));
     }
     releaseLocks = acquireInstallLocks(options.dir, deps.acquireLease);
-    if ((0, import_node_fs11.existsSync)(databasePath(options.dir))) {
-      const backups = (0, import_node_path12.join)(options.dir, "backups");
+    if ((0, import_node_fs12.existsSync)(databasePath(options.dir))) {
+      const backups = (0, import_node_path13.join)(options.dir, "backups");
       ensurePrivateDir(backups);
-      backupPath = (0, import_node_path12.join)(
+      backupPath = (0, import_node_path13.join)(
         backups,
         `pre-upgrade-${currentVersion}-to-${expectedVersion}-${timestampSlug(deps.now())}.sqlite`
       );
@@ -4562,6 +4770,9 @@ async function upgradeInstallation(options, injected = {}) {
     }
     deps.activate(options.dir, stage);
     activated = true;
+    machineData = performMachineDataCleanup(options.dir, machineDataPaths(options.dir), deps.now, {
+      clear: deps.clearHistory
+    });
     releaseLocks();
     releaseLocks = null;
     for (const component of running) deps.service.start(options.dir, component);
@@ -4577,7 +4788,7 @@ async function upgradeInstallation(options, injected = {}) {
     });
     restoreStartup(options.dir, deps, snapshot.enabled, false);
     const now = new Date(deps.now()).toISOString();
-    if (backupPath !== null && (0, import_node_fs11.existsSync)(backupPath)) {
+    if (backupPath !== null && (0, import_node_fs12.existsSync)(backupPath)) {
       const info = deps.inspect(backupPath);
       const record = {
         path: backupPath,
@@ -4601,13 +4812,15 @@ async function upgradeInstallation(options, injected = {}) {
         activatedAt: now
       }
     });
+    completeMachineDataCleanup(options.dir, machineData, expectedVersion);
     return {
       version: expectedVersion,
       previousVersion: currentVersion,
       backupPath,
       schemaVersion: verification.database?.schemaVersion ?? expectedSchema,
       serviceRestarted: running.length > 0,
-      verification
+      verification,
+      machineHistory: machineData.report
     };
   } catch (error2) {
     releaseLocks?.();
@@ -4617,6 +4830,7 @@ async function upgradeInstallation(options, injected = {}) {
       config,
       previousVersion: currentVersion,
       backupPath,
+      machineData,
       running,
       startup: snapshot.enabled,
       activated,
@@ -4630,13 +4844,13 @@ async function upgradeInstallation(options, injected = {}) {
   } finally {
     releaseLocks?.();
     releaseOperation();
-    if ((0, import_node_fs11.existsSync)(stage)) (0, import_node_fs11.rmSync)(stage, { recursive: true, force: true });
+    if ((0, import_node_fs12.existsSync)(stage)) (0, import_node_fs12.rmSync)(stage, { recursive: true, force: true });
   }
 }
 function rollbackBackup(options) {
   if (options.explicitBackup !== void 0) {
     const path2 = options.explicitBackup;
-    if (!(0, import_node_fs11.existsSync)(path2)) {
+    if (!(0, import_node_fs12.existsSync)(path2)) {
       throw new OperationsError("backup-missing", `rollback backup does not exist: ${path2}`);
     }
     const info2 = options.deps.inspect(path2);
@@ -4655,7 +4869,7 @@ function rollbackBackup(options) {
       `database schema ${options.previousSupport.schemaVersion} is newer than previous runtime ${options.previousVersion} (schema ${options.previousSupport.supportedSchemaVersion}); no paired pre-upgrade backup is recorded for ${options.currentVersion}. Re-run with --backup PATH naming a copy that matches schema ${options.previousSupport.supportedSchemaVersion} or older`
     );
   }
-  if (!(0, import_node_fs11.existsSync)(recorded.path)) {
+  if (!(0, import_node_fs12.existsSync)(recorded.path)) {
     throw new OperationsError(
       "backup-missing",
       `paired pre-upgrade backup for ${options.currentVersion} is missing: ${recorded.path}`
@@ -4677,10 +4891,10 @@ async function rollbackInstallation(options, injected = {}) {
   const deps = dependencies(injected);
   const config = readSetup(options.dir);
   if (!config) throw new OperationsError("not-installed", "No installation found. Run rigscope install first.");
-  const runtime = (0, import_node_path12.join)(options.dir, "runtime");
-  const previousRuntime = (0, import_node_path12.join)(options.dir, "runtime-previous");
-  if (!(0, import_node_fs11.existsSync)(runtime)) throw new OperationsError("not-installed", "No active runtime is installed.");
-  if (!(0, import_node_fs11.existsSync)(previousRuntime)) {
+  const runtime = (0, import_node_path13.join)(options.dir, "runtime");
+  const previousRuntime = (0, import_node_path13.join)(options.dir, "runtime-previous");
+  if (!(0, import_node_fs12.existsSync)(runtime)) throw new OperationsError("not-installed", "No active runtime is installed.");
+  if (!(0, import_node_fs12.existsSync)(previousRuntime)) {
     throw new OperationsError("no-previous-release", "No previous runtime is available for rollback.");
   }
   const currentVersion = runtimeVersion(runtime);
@@ -4691,19 +4905,19 @@ async function rollbackInstallation(options, injected = {}) {
   const snapshot = snapshotComponents(options.dir, deps);
   const running = snapshot.running;
   let releaseLocks = null;
-  const releaseOperation = deps.acquireLease((0, import_node_path12.join)(options.dir, "run", "operation.lock"));
+  const releaseOperation = deps.acquireLease((0, import_node_path13.join)(options.dir, "run", "operation.lock"));
   let restoredBackup = null;
   let preRestoreBackup = null;
   let swapped = false;
   try {
     stopComponents(options.dir, deps, running);
     assertComponentsStopped(options.dir, deps, running);
-    if (running.includes("hub") || componentEnabled(config, "hub") || (0, import_node_fs11.existsSync)(databasePath(options.dir))) {
+    if (running.includes("hub") || componentEnabled(config, "hub") || (0, import_node_fs12.existsSync)(databasePath(options.dir))) {
       assertNoActiveHubLock(databasePath(options.dir));
     }
     releaseLocks = acquireInstallLocks(options.dir, deps.acquireLease);
     const path2 = databasePath(options.dir);
-    if ((0, import_node_fs11.existsSync)(path2)) {
+    if ((0, import_node_fs12.existsSync)(path2)) {
       const previousSupport = deps.inspectRuntime(previousRuntime, path2);
       if (!previousSupport.integrityOk || previousSupport.newerSchema || previousSupport.ledgerProblem !== null) {
         const backup3 = rollbackBackup({
@@ -4774,7 +4988,7 @@ async function rollbackInstallation(options, injected = {}) {
         if (status.active) deps.service.stop(options.dir, component);
       }
       assertComponentsStopped(options.dir, deps, COMPONENT_LIST);
-      if ((0, import_node_fs11.existsSync)(databasePath(options.dir))) assertNoActiveHubLock(databasePath(options.dir));
+      if ((0, import_node_fs12.existsSync)(databasePath(options.dir))) assertNoActiveHubLock(databasePath(options.dir));
       releaseLocks = acquireInstallLocks(options.dir, deps.acquireLease);
     } catch (stopError) {
       throw new OperationsError("rollback-failed", `rollback failed: ${errorMessage(error2)}. Recovery refused while runtime ownership is uncertain: ${errorMessage(stopError)}`, { cause: error2 });
@@ -4788,7 +5002,7 @@ async function rollbackInstallation(options, injected = {}) {
         safeToRestart = false;
       }
     }
-    if (preRestoreBackup !== null && (0, import_node_fs11.existsSync)(preRestoreBackup)) {
+    if (preRestoreBackup !== null && (0, import_node_fs12.existsSync)(preRestoreBackup)) {
       try {
         await deps.restore({
           input: preRestoreBackup,
@@ -4803,7 +5017,7 @@ async function rollbackInstallation(options, injected = {}) {
         safeToRestart = false;
       }
     }
-    if (safeToRestart && running.includes("hub") && (0, import_node_fs11.existsSync)(databasePath(options.dir))) {
+    if (safeToRestart && running.includes("hub") && (0, import_node_fs12.existsSync)(databasePath(options.dir))) {
       try {
         const info = deps.inspectRuntime(runtime, databasePath(options.dir));
         if (!info.integrityOk || info.newerSchema || info.ledgerProblem !== null) throw new Error("runtime/database compatibility is not established");
@@ -4850,17 +5064,17 @@ async function rollbackInstallation(options, injected = {}) {
 
 // src/cli/lifecycle.ts
 function collectorEnrolled(dir) {
-  const path2 = (0, import_node_path13.join)(dir, "collector", "state.json");
-  if (!(0, import_node_fs12.existsSync)(path2)) return false;
+  const path2 = (0, import_node_path14.join)(dir, "collector", "state.json");
+  if (!(0, import_node_fs13.existsSync)(path2)) return false;
   const state = JSON.parse(readPrivate(path2));
   return Array.isArray(state.destinations) && state.destinations.length > 0;
 }
 var AWAITING_CONNECTION = "Collector is awaiting connection. Run rigscope connect https://your-hub first.";
 function assertNoCompetingRuntime(dir, component) {
   const locks = [
-    (0, import_node_path13.join)(dir, "run", component === "hub" ? "hub.lock" : "collector.lock"),
-    (0, import_node_path13.join)(dir, "run", "rigscope.lock"),
-    ...component === "collector" ? [(0, import_node_path13.join)(dir, "collector", "collector-runtime.lock")] : []
+    (0, import_node_path14.join)(dir, "run", component === "hub" ? "hub.lock" : "collector.lock"),
+    (0, import_node_path14.join)(dir, "run", "rigscope.lock"),
+    ...component === "collector" ? [(0, import_node_path14.join)(dir, "collector", "collector-runtime.lock")] : []
   ];
   const releases = [];
   try {
@@ -4879,11 +5093,11 @@ function assertNoCompetingRuntime(dir, component) {
 async function startInstallation(dir, component, injected = {}) {
   const config = readSetup(dir);
   if (!config) throw new Error("No background service installed. Run rigscope install first.");
-  if (!(0, import_node_fs12.existsSync)((0, import_node_path13.join)(dir, "runtime"))) throw new Error("No background service installed. Run rigscope install first.");
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path14.join)(dir, "runtime"))) throw new Error("No background service installed. Run rigscope install first.");
   const selected = component ? [component] : enabledComponents(config);
   if (selected.length === 0) throw new Error("No enabled components. Run rigscope enable hub or rigscope enable collector.");
   for (const target of selected) {
-    if (!(0, import_node_fs12.existsSync)(unitPath(dir, target))) throw new Error("No background service installed. Run rigscope install first.");
+    if (!(0, import_node_fs13.existsSync)(unitPath(dir, target))) throw new Error("No background service installed. Run rigscope install first.");
   }
   const status = injected.status ?? serviceStatus;
   const start = injected.start ?? systemctl;
@@ -4911,7 +5125,7 @@ async function startInstallation(dir, component, injected = {}) {
       await (injected.verify ?? verifyRunningInstallation)({
         dir,
         config,
-        expectedVersion: runtimeVersion((0, import_node_path13.join)(dir, "runtime")),
+        expectedVersion: runtimeVersion((0, import_node_path14.join)(dir, "runtime")),
         components: started,
         requireActive: started
       });
@@ -4995,11 +5209,11 @@ function printHelp(message, options = {}) {
 
 // src/cli/mutation.ts
 async function resumeComponent(dir, component) {
-  if ((0, import_node_fs13.existsSync)((0, import_node_path14.join)(dir, "runtime"))) return startInstallation(dir, component);
-  const run = (0, import_node_path14.join)(dir, "run");
-  (0, import_node_fs13.mkdirSync)(run, { recursive: true, mode: 448 });
-  const log = (0, import_node_path14.join)(run, `${component}.log`);
-  const fd = (0, import_node_fs13.openSync)(log, "a", 384);
+  if ((0, import_node_fs14.existsSync)((0, import_node_path15.join)(dir, "runtime"))) return startInstallation(dir, component);
+  const run = (0, import_node_path15.join)(dir, "run");
+  (0, import_node_fs14.mkdirSync)(run, { recursive: true, mode: 448 });
+  const log = (0, import_node_path15.join)(run, `${component}.log`);
+  const fd = (0, import_node_fs14.openSync)(log, "a", 384);
   let child;
   try {
     child = (0, import_node_child_process3.spawn)(process.execPath, [process.argv[1], "run", component, "--state-dir", dir], {
@@ -5008,7 +5222,7 @@ async function resumeComponent(dir, component) {
       env: process.env
     });
   } finally {
-    (0, import_node_fs13.closeSync)(fd);
+    (0, import_node_fs14.closeSync)(fd);
   }
   let failure;
   child.on("error", (error2) => {
@@ -5019,7 +5233,7 @@ async function resumeComponent(dir, component) {
   while (Date.now() < deadline) {
     if (failure || child.exitCode !== null || child.signalCode !== null) break;
     try {
-      const owner = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path14.join)(run, `${component}.lock`), "utf8"));
+      const owner = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path15.join)(run, `${component}.lock`), "utf8"));
       if (owner.pid === child.pid) return "started";
     } catch {
     }
@@ -5075,12 +5289,20 @@ async function prepareMutation(dir, selected, options, deps = {}) {
 
 // src/cli/runtime.ts
 var import_node_child_process4 = require("node:child_process");
-var import_node_path15 = require("node:path");
+var import_node_path16 = require("node:path");
+function collectorQueueModeEnvironment(env) {
+  const raw = env["COLLECTOR_QUEUE_MODE"]?.trim();
+  if (raw === void 0 || raw === "") return {};
+  const issues = [];
+  const queueMode = parseQueueMode(env, issues);
+  if (issues.length > 0) throw new Error(issues.join("\n"));
+  return { COLLECTOR_QUEUE_MODE: queueMode };
+}
 function componentLeasePath(dir, component) {
-  return (0, import_node_path15.join)(dir, "run", `${component}.lock`);
+  return (0, import_node_path16.join)(dir, "run", `${component}.lock`);
 }
 function combinedLeasePath(dir) {
-  return (0, import_node_path15.join)(dir, "run", "rigscope.lock");
+  return (0, import_node_path16.join)(dir, "run", "rigscope.lock");
 }
 function label(component) {
   return component === "hub" ? "Hub" : "Collector";
@@ -5097,6 +5319,7 @@ async function runInstallation(root, dir, component) {
     console.error("No components are enabled. Run rigscope enable hub or rigscope enable collector.");
     return 0;
   }
+  const collectorEnvironment = selected.includes("collector") ? collectorQueueModeEnvironment(process.env) : {};
   if (selected.includes("collector") && !collectorHasDestinations(dir)) {
     console.log("Collector awaiting connection. Run rigscope connect https://your-hub.");
     const remaining = selected.filter((role) => role !== "collector");
@@ -5136,13 +5359,14 @@ async function runInstallation(root, dir, component) {
   process.on("SIGTERM", signal);
   process.on("SIGINT", signal);
   function launch(role) {
-    const child = (0, import_node_child_process4.spawn)(process.execPath, [(0, import_node_path15.join)(root, "dist", `${role}.cjs`)], { cwd: root, stdio: "inherit", env: {
+    const child = (0, import_node_child_process4.spawn)(process.execPath, [(0, import_node_path16.join)(root, "dist", `${role}.cjs`)], { cwd: root, stdio: "inherit", env: {
       ...environment,
       NODE_ENV: "production",
       ...role === "hub" ? hubEnvironment(dir, config) : {
         COLLECTOR_MODE: "real",
-        COLLECTOR_STATE_FILE: (0, import_node_path15.join)(dir, "collector", "state.json"),
-        COLLECTOR_HEALTH_FILE: (0, import_node_path15.join)(dir, "run", "collector-health.json")
+        COLLECTOR_STATE_FILE: (0, import_node_path16.join)(dir, "collector", "state.json"),
+        COLLECTOR_HEALTH_FILE: (0, import_node_path16.join)(dir, "run", "collector-health.json"),
+        ...collectorEnvironment
       }
     } });
     children.add(child);
@@ -5169,8 +5393,8 @@ async function runInstallation(root, dir, component) {
 }
 
 // src/cli/doctor.ts
-var import_node_fs14 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path17 = require("node:path");
 var DEFAULT_DEPENDENCIES = {
   serviceStatus,
   probeHealth,
@@ -5180,7 +5404,7 @@ var DEFAULT_DEPENDENCIES = {
   inspectDatabase,
   diskFree: (path2) => {
     try {
-      const stats = (0, import_node_fs14.statfsSync)(path2);
+      const stats = (0, import_node_fs15.statfsSync)(path2);
       return { free: Number(stats.bavail) * Number(stats.bsize), total: Number(stats.blocks) * Number(stats.bsize) };
     } catch {
       return null;
@@ -5189,13 +5413,13 @@ var DEFAULT_DEPENDENCIES = {
   sensorReadable: (paths) => paths.filter((path2) => {
     let fd;
     try {
-      fd = (0, import_node_fs14.openSync)(path2, "r");
-      (0, import_node_fs14.readSync)(fd, Buffer.alloc(1), 0, 1, 0);
+      fd = (0, import_node_fs15.openSync)(path2, "r");
+      (0, import_node_fs15.readSync)(fd, Buffer.alloc(1), 0, 1, 0);
       return true;
     } catch {
       return false;
     } finally {
-      if (fd !== void 0) (0, import_node_fs14.closeSync)(fd);
+      if (fd !== void 0) (0, import_node_fs15.closeSync)(fd);
     }
   })
 };
@@ -5257,10 +5481,10 @@ async function diagnoseInstallation(dir, injected = {}) {
   }
   for (const [id, label3, path2] of [
     ["state-dir", "State directory", dir],
-    ["config-mode", "Configuration permissions", (0, import_node_path16.join)(dir, "config.json")]
+    ["config-mode", "Configuration permissions", (0, import_node_path17.join)(dir, "config.json")]
   ]) {
     try {
-      const stat = (0, import_node_fs14.lstatSync)(path2);
+      const stat = (0, import_node_fs15.lstatSync)(path2);
       const privateEntry = id === "state-dir" ? stat.isDirectory() : stat.isFile();
       const privateMode = (stat.mode & 63) === 0;
       add({
@@ -5275,7 +5499,7 @@ async function diagnoseInstallation(dir, injected = {}) {
     }
   }
   let runtime = null;
-  if (!(0, import_node_fs14.existsSync)((0, import_node_path16.join)(dir, "runtime"))) {
+  if (!(0, import_node_fs15.existsSync)((0, import_node_path17.join)(dir, "runtime"))) {
     add({
       id: "runtime",
       label: "Runtime",
@@ -5285,9 +5509,9 @@ async function diagnoseInstallation(dir, injected = {}) {
     });
   } else {
     try {
-      assertRuntimeArtifacts((0, import_node_path16.join)(dir, "runtime"), "runtime");
-      const version2 = runtimeVersion((0, import_node_path16.join)(dir, "runtime"));
-      runtime = (0, import_node_path16.join)(dir, "runtime");
+      assertRuntimeArtifacts((0, import_node_path17.join)(dir, "runtime"), "runtime");
+      const version2 = runtimeVersion((0, import_node_path17.join)(dir, "runtime"));
+      runtime = (0, import_node_path17.join)(dir, "runtime");
       add({ id: "runtime", label: "Runtime", status: "ok", detail: `rigscope ${version2}` });
     } catch (error2) {
       add({
@@ -5299,9 +5523,9 @@ async function diagnoseInstallation(dir, injected = {}) {
       });
     }
   }
-  if ((0, import_node_fs14.existsSync)((0, import_node_path16.join)(dir, "runtime-previous"))) {
+  if ((0, import_node_fs15.existsSync)((0, import_node_path17.join)(dir, "runtime-previous"))) {
     try {
-      add({ id: "previous-runtime", label: "Previous runtime", status: "ok", detail: `rigscope ${runtimeVersion((0, import_node_path16.join)(dir, "runtime-previous"))}` });
+      add({ id: "previous-runtime", label: "Previous runtime", status: "ok", detail: `rigscope ${runtimeVersion((0, import_node_path17.join)(dir, "runtime-previous"))}` });
     } catch (error2) {
       add({ id: "previous-runtime", label: "Previous runtime", status: "warn", detail: errorText2(error2) });
     }
@@ -5363,7 +5587,7 @@ async function diagnoseInstallation(dir, injected = {}) {
   const collectorActive = services.collector.active;
   if (hubEnabled || hubActive) {
     const path2 = databasePath(dir);
-    if (!(0, import_node_fs14.existsSync)(path2)) {
+    if (!(0, import_node_fs15.existsSync)(path2)) {
       add({
         id: "database",
         label: "Database",
@@ -5392,7 +5616,7 @@ async function diagnoseInstallation(dir, injected = {}) {
         });
       }
     }
-    const space = deps.diskFree((0, import_node_path16.join)(dir, "hub"));
+    const space = deps.diskFree((0, import_node_path17.join)(dir, "hub"));
     if (space !== null) {
       const free = space.free;
       add({
@@ -5406,9 +5630,9 @@ async function diagnoseInstallation(dir, injected = {}) {
   }
   if (hubEnabled || hubActive) {
     if (config.origin) {
-      const socket = config.socket ?? (0, import_node_path16.join)(dir, "run", "hub.sock");
+      const socket = config.socket ?? (0, import_node_path17.join)(dir, "run", "hub.sock");
       try {
-        const stat = (0, import_node_fs14.lstatSync)(socket);
+        const stat = (0, import_node_fs15.lstatSync)(socket);
         add({
           id: "socket",
           label: "Unix socket",
@@ -5450,7 +5674,7 @@ async function diagnoseInstallation(dir, injected = {}) {
     }
     if (hubActive) {
       try {
-        const target = healthTarget({ component: "hub", port: config.port, origin: config.origin, socket: config.socket ?? (0, import_node_path16.join)(dir, "run", "hub.sock") });
+        const target = healthTarget({ component: "hub", port: config.port, origin: config.origin, socket: config.socket ?? (0, import_node_path17.join)(dir, "run", "hub.sock") });
         const health = await deps.probeHealth(target, 3e3);
         const expected = runtime ? runtimeVersion(runtime) : null;
         const reported = typeof health.body?.version === "string" ? health.body.version : null;
@@ -5468,7 +5692,7 @@ async function diagnoseInstallation(dir, injected = {}) {
     }
   }
   if (collectorEnabled || collectorActive) {
-    const statePath = (0, import_node_path16.join)(dir, "collector", "state.json");
+    const statePath = (0, import_node_path17.join)(dir, "collector", "state.json");
     try {
       const raw = readPrivate(statePath);
       const state = JSON.parse(raw);
@@ -5543,17 +5767,17 @@ async function diagnoseInstallation(dir, injected = {}) {
 function hubEnvironment2(dir, config) {
   return {
     ...!config.origin ? { HUB_HOST: "127.0.0.1", HUB_PORT: String(config.port) } : {},
-    HUB_STATE_FILE: (0, import_node_path16.join)(dir, "hub", "enrollment.json"),
+    HUB_STATE_FILE: (0, import_node_path17.join)(dir, "hub", "enrollment.json"),
     HUB_DATABASE_PATH: databasePath(dir),
     HUB_BROWSER_USERS: JSON.stringify(config.users),
     HUB_COLLECTORS: JSON.stringify(config.collectors),
     ...config.maxCollectorConnections === void 0 ? {} : { HUB_MAX_COLLECTOR_CONNECTIONS: String(config.maxCollectorConnections) },
-    ...config.origin ? { HUB_PUBLIC_ORIGIN: config.origin, HUB_SOCKET_PATH: config.socket ?? (0, import_node_path16.join)(dir, "run", "hub.sock") } : {}
+    ...config.origin ? { HUB_PUBLIC_ORIGIN: config.origin, HUB_SOCKET_PATH: config.socket ?? (0, import_node_path17.join)(dir, "run", "hub.sock") } : {}
   };
 }
 function collectorAwaiting(dir) {
   try {
-    const state = JSON.parse(readPrivate((0, import_node_path16.join)(dir, "collector", "state.json")));
+    const state = JSON.parse(readPrivate((0, import_node_path17.join)(dir, "collector", "state.json")));
     return !Array.isArray(state.destinations) || state.destinations.length === 0;
   } catch (error2) {
     return error2.code === "ENOENT";
@@ -5565,13 +5789,13 @@ function powerCounterPaths() {
     if (depth > 3 || paths.length >= 64) return;
     let entries;
     try {
-      entries = (0, import_node_fs14.readdirSync)(directory, { withFileTypes: true });
+      entries = (0, import_node_fs15.readdirSync)(directory, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry2 of entries) {
       if (paths.length >= 64) return;
-      const path2 = (0, import_node_path16.join)(directory, entry2.name);
+      const path2 = (0, import_node_path17.join)(directory, entry2.name);
       if (entry2.name === "energy_uj") {
         paths.push(path2);
         continue;
@@ -5615,8 +5839,8 @@ function errorText2(error2) {
 }
 
 // src/operations/recovery.ts
-var import_node_fs15 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path18 = require("node:path");
 var import_node_sqlite3 = require("node:sqlite");
 var MAX_AUDIT_EVENTS = 1e3;
 var AUDIT_ACTOR = "local-recovery";
@@ -5631,13 +5855,13 @@ async function recoverAdminPassword(options) {
   if (typeof options.password !== "string" || options.password.length === 0 || options.password.length > MAX_BROWSER_PASSWORD_CHARS) {
     throw new OperationsError("invalid-password", `password must be 1..${MAX_BROWSER_PASSWORD_CHARS} characters`);
   }
-  if (!(0, import_node_fs15.existsSync)(database)) {
+  if (!(0, import_node_fs16.existsSync)(database)) {
     throw new OperationsError("missing-database", `hub database does not exist: ${database}`);
   }
   assertPrivateRegularFile(database, "database");
-  const ownLock = (0, import_node_path17.resolve)(`${database}.hub.lock`);
+  const ownLock = (0, import_node_path18.resolve)(`${database}.hub.lock`);
   const otherLock = findHubLock(database);
-  if (otherLock !== null && (0, import_node_path17.resolve)(otherLock) !== ownLock) {
+  if (otherLock !== null && (0, import_node_path18.resolve)(otherLock) !== ownLock) {
     throw new OperationsError(
       "hub-active",
       `a hub lock exists at ${otherLock}; stop the hub and inspect that lock before recovery`
@@ -5735,10 +5959,10 @@ async function recoverAdminPassword(options) {
 }
 
 // src/cli/system.ts
-var import_node_fs16 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 var import_node_child_process5 = require("node:child_process");
-var import_node_crypto11 = require("node:crypto");
-var import_node_path18 = require("node:path");
+var import_node_crypto12 = require("node:crypto");
+var import_node_path19 = require("node:path");
 var import_node_sqlite4 = require("node:sqlite");
 var import_node_util = require("node:util");
 var SYSTEM_SCOPE = "system";
@@ -5848,24 +6072,24 @@ function createSystemHost(overrides = {}) {
 }
 function defaultSystemPaths(overrides = {}) {
   return {
-    prefix: (0, import_node_path18.resolve)(overrides.prefix ?? "/opt/rigscope"),
-    configDir: (0, import_node_path18.resolve)(overrides.configDir ?? "/etc/rigscope"),
-    stateDir: (0, import_node_path18.resolve)(overrides.stateDir ?? "/var/lib/rigscope"),
-    unitsDir: (0, import_node_path18.resolve)(overrides.unitsDir ?? "/etc/systemd/system"),
-    sysusersDir: (0, import_node_path18.resolve)(overrides.sysusersDir ?? "/etc/sysusers.d"),
-    udevRulesDir: (0, import_node_path18.resolve)(overrides.udevRulesDir ?? "/etc/udev/rules.d"),
-    powercapRoot: (0, import_node_path18.resolve)(overrides.powercapRoot ?? "/sys/class/powercap")
+    prefix: (0, import_node_path19.resolve)(overrides.prefix ?? "/opt/rigscope"),
+    configDir: (0, import_node_path19.resolve)(overrides.configDir ?? "/etc/rigscope"),
+    stateDir: (0, import_node_path19.resolve)(overrides.stateDir ?? "/var/lib/rigscope"),
+    unitsDir: (0, import_node_path19.resolve)(overrides.unitsDir ?? "/etc/systemd/system"),
+    sysusersDir: (0, import_node_path19.resolve)(overrides.sysusersDir ?? "/etc/sysusers.d"),
+    udevRulesDir: (0, import_node_path19.resolve)(overrides.udevRulesDir ?? "/etc/udev/rules.d"),
+    powercapRoot: (0, import_node_path19.resolve)(overrides.powercapRoot ?? "/sys/class/powercap")
   };
 }
 function unitNamesForComponents(components) {
   return COMPONENTS3.filter((component) => componentSet(components)[component]).map(unitFor);
 }
 function isWithin(parent, candidate) {
-  const rel = (0, import_node_path18.relative)((0, import_node_path18.resolve)(parent), (0, import_node_path18.resolve)(candidate));
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${import_node_path18.sep}`) && !(0, import_node_path18.isAbsolute)(rel);
+  const rel = (0, import_node_path19.relative)((0, import_node_path19.resolve)(parent), (0, import_node_path19.resolve)(candidate));
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${import_node_path19.sep}`) && !(0, import_node_path19.isAbsolute)(rel);
 }
 function ensureAbsolute(path2, label3) {
-  const absolute = (0, import_node_path18.resolve)(path2);
+  const absolute = (0, import_node_path19.resolve)(path2);
   if (/[\0\r\n]/.test(absolute)) throw new SystemError("unsafe-path", `${label3} contains control characters`);
   if (absolute === "/") throw new SystemError("unsafe-path", `${label3} must not be the filesystem root`);
   for (const forbidden of ["/home", "/root", "/proc", "/sys", "/dev", "/boot"]) {
@@ -5879,7 +6103,7 @@ function validateSystemPaths(input = {}) {
   const paths = defaultSystemPaths(input);
   for (const [label3, value] of Object.entries(paths)) {
     if (label3 === "powercapRoot") {
-      if (!(0, import_node_path18.isAbsolute)(value) || /[\0\r\n]/.test(value) || (0, import_node_path18.resolve)(value) === "/") {
+      if (!(0, import_node_path19.isAbsolute)(value) || /[\0\r\n]/.test(value) || (0, import_node_path19.resolve)(value) === "/") {
         throw new SystemError("unsafe-path", `powercap root is unsafe: ${value}`);
       }
     } else {
@@ -5935,18 +6159,18 @@ function runMaybe(host, command, args, options) {
   return host.run(command, args, options);
 }
 function sha256File2(path2) {
-  return (0, import_node_crypto11.createHash)("sha256").update((0, import_node_fs16.readFileSync)(path2)).digest("hex");
+  return (0, import_node_crypto12.createHash)("sha256").update((0, import_node_fs17.readFileSync)(path2)).digest("hex");
 }
 function atomicWrite(path2, content, mode) {
-  (0, import_node_fs16.mkdirSync)((0, import_node_path18.dirname)(path2), { recursive: true, mode: 493 });
-  const temporary = (0, import_node_path18.join)((0, import_node_path18.dirname)(path2), `.${(0, import_node_path18.basename)(path2)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  (0, import_node_fs17.mkdirSync)((0, import_node_path19.dirname)(path2), { recursive: true, mode: 493 });
+  const temporary = (0, import_node_path19.join)((0, import_node_path19.dirname)(path2), `.${(0, import_node_path19.basename)(path2)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
   try {
-    (0, import_node_fs16.writeFileSync)(temporary, content, { mode });
-    (0, import_node_fs16.chmodSync)(temporary, mode);
-    (0, import_node_fs16.renameSync)(temporary, path2);
+    (0, import_node_fs17.writeFileSync)(temporary, content, { mode });
+    (0, import_node_fs17.chmodSync)(temporary, mode);
+    (0, import_node_fs17.renameSync)(temporary, path2);
   } catch (error2) {
     try {
-      (0, import_node_fs16.unlinkSync)(temporary);
+      (0, import_node_fs17.unlinkSync)(temporary);
     } catch {
     }
     throw error2;
@@ -5955,12 +6179,12 @@ function atomicWrite(path2, content, mode) {
 function ensureDirectory(path2, mode, privateDirectory2 = false) {
   let stat;
   try {
-    stat = (0, import_node_fs16.lstatSync)(path2);
+    stat = (0, import_node_fs17.lstatSync)(path2);
   } catch (error2) {
     if (error2.code !== "ENOENT") throw error2;
-    (0, import_node_fs16.mkdirSync)(path2, { recursive: true, mode });
-    (0, import_node_fs16.chmodSync)(path2, mode);
-    stat = (0, import_node_fs16.lstatSync)(path2);
+    (0, import_node_fs17.mkdirSync)(path2, { recursive: true, mode });
+    (0, import_node_fs17.chmodSync)(path2, mode);
+    stat = (0, import_node_fs17.lstatSync)(path2);
   }
   if (!stat.isDirectory() || stat.isSymbolicLink()) {
     throw new SystemError("unsafe-path", `${path2} must be a real directory`);
@@ -5975,8 +6199,8 @@ function isDefaultSystemLayout(paths) {
 }
 function assertManagedPathSafety(paths, enforceRoot) {
   for (const path2 of [paths.prefix, paths.configDir, paths.stateDir, paths.unitsDir, paths.sysusersDir, paths.udevRulesDir]) {
-    if (!(0, import_node_fs16.existsSync)(path2)) continue;
-    const stat = (0, import_node_fs16.lstatSync)(path2);
+    if (!(0, import_node_fs17.existsSync)(path2)) continue;
+    const stat = (0, import_node_fs17.lstatSync)(path2);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
       throw new SystemError("unsafe-path", `${path2} must be a real directory`);
     }
@@ -5989,8 +6213,8 @@ function assertManagedPathSafety(paths, enforceRoot) {
   }
 }
 function writeManagedFile(path2, content, mode, replace) {
-  if ((0, import_node_fs16.existsSync)(path2)) {
-    const stat = (0, import_node_fs16.lstatSync)(path2);
+  if ((0, import_node_fs17.existsSync)(path2)) {
+    const stat = (0, import_node_fs17.lstatSync)(path2);
     if (!stat.isFile() || stat.isSymbolicLink()) {
       throw new SystemError("unsafe-path", `${path2} must be a regular file, not a symlink`);
     }
@@ -6029,7 +6253,7 @@ function parseEnvValue(value) {
 function readEnvDocument(path2) {
   let raw;
   try {
-    raw = (0, import_node_fs16.readFileSync)(path2, "utf8");
+    raw = (0, import_node_fs17.readFileSync)(path2, "utf8");
   } catch (error2) {
     if (error2.code === "ENOENT") return null;
     throw error2;
@@ -6076,43 +6300,43 @@ function connectDestinationUrl(value) {
   return url.href;
 }
 function hubDatabasePath(paths) {
-  return (0, import_node_path18.join)(paths.stateDir, "hub", "telemetry.sqlite");
+  return (0, import_node_path19.join)(paths.stateDir, "hub", "telemetry.sqlite");
 }
 function hubEnrollmentPath(paths) {
-  return (0, import_node_path18.join)(paths.stateDir, "hub", "enrollment.json");
+  return (0, import_node_path19.join)(paths.stateDir, "hub", "enrollment.json");
 }
 function hubSocketPath(paths) {
-  return (0, import_node_path18.join)(paths.stateDir, "hub", "run", "hub.sock");
+  return (0, import_node_path19.join)(paths.stateDir, "hub", "run", "hub.sock");
 }
 function collectorStatePath2(paths) {
-  return (0, import_node_path18.join)(paths.stateDir, "collector", "state.json");
+  return (0, import_node_path19.join)(paths.stateDir, "collector", "state.json");
 }
 function hubEnvPath(paths) {
-  return (0, import_node_path18.join)(paths.configDir, "hub.env");
+  return (0, import_node_path19.join)(paths.configDir, "hub.env");
 }
 function collectorEnvPath(paths) {
-  return (0, import_node_path18.join)(paths.configDir, "collector.env");
+  return (0, import_node_path19.join)(paths.configDir, "collector.env");
 }
 function sysusersPath(paths) {
-  return (0, import_node_path18.join)(paths.sysusersDir, SYSUSERS_NAME);
+  return (0, import_node_path19.join)(paths.sysusersDir, SYSUSERS_NAME);
 }
 function powerSysusersPath(paths) {
-  return (0, import_node_path18.join)(paths.sysusersDir, POWER_SYSUSERS_NAME);
+  return (0, import_node_path19.join)(paths.sysusersDir, POWER_SYSUSERS_NAME);
 }
 function raplRulePath(paths) {
-  return (0, import_node_path18.join)(paths.udevRulesDir, RAPL_RULE_NAME);
+  return (0, import_node_path19.join)(paths.udevRulesDir, RAPL_RULE_NAME);
 }
 function stateFilePath(paths) {
-  return (0, import_node_path18.join)(paths.stateDir, STATE_FILE_NAME);
+  return (0, import_node_path19.join)(paths.stateDir, STATE_FILE_NAME);
 }
 function readCollectorIdentity(path2) {
-  if (!(0, import_node_fs16.existsSync)(path2)) return null;
-  const stat = (0, import_node_fs16.lstatSync)(path2);
+  if (!(0, import_node_fs17.existsSync)(path2)) return null;
+  const stat = (0, import_node_fs17.lstatSync)(path2);
   if (!stat.isFile() || stat.isSymbolicLink()) throw new SystemError("unsafe-path", `${path2} must be a regular file`);
   if ((stat.mode & 63) !== 0) throw new SystemError("insecure-permissions", `${path2} must be private (0600)`);
   let raw;
   try {
-    raw = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
+    raw = JSON.parse((0, import_node_fs17.readFileSync)(path2, "utf8"));
   } catch {
     throw new SystemError("invalid-file", `${path2} is not valid JSON`);
   }
@@ -6146,7 +6370,7 @@ function readCollectorIdentity(path2) {
   return { collectorId: record.collectorId, destinations };
 }
 function writeCollectorIdentity(path2, identity) {
-  ensureDirectory((0, import_node_path18.dirname)(path2), 448, true);
+  ensureDirectory((0, import_node_path19.dirname)(path2), 448, true);
   atomicWrite(path2, `${JSON.stringify(identity)}
 `, 384);
 }
@@ -6186,7 +6410,7 @@ function ensureHubOwner(paths) {
     if (!Array.isArray(parsed)) throw new SystemError("invalid-config", "HUB_BROWSER_USERS must be a JSON array");
     if (parsed.length > 0) return void 0;
   }
-  const password = (0, import_node_crypto11.randomBytes)(18).toString("base64url");
+  const password = (0, import_node_crypto12.randomBytes)(18).toString("base64url");
   const users = [{ username: "owner", passwordHash: hashPassword(password), machineIds: "*", admin: true }];
   writeEnvValue(hubEnvPath(paths), "HUB_BROWSER_USERS", JSON.stringify(users));
   return password;
@@ -6237,7 +6461,7 @@ function updateHubCollectorRegistry(paths, identity) {
 }
 function registerCollectorInHubDatabase(paths, identity, host) {
   const database = hubDatabasePath(paths);
-  if (!(0, import_node_fs16.existsSync)(database)) return { inserted: false };
+  if (!(0, import_node_fs17.existsSync)(database)) return { inserted: false };
   const db = new import_node_sqlite4.DatabaseSync(database, { timeout: 5e3 });
   try {
     const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='collector_registry'").get();
@@ -6252,7 +6476,7 @@ function registerCollectorInHubDatabase(paths, identity, host) {
 }
 function findCollectorInHubDatabase(paths, collectorId) {
   const database = hubDatabasePath(paths);
-  if (!(0, import_node_fs16.existsSync)(database)) return null;
+  if (!(0, import_node_fs17.existsSync)(database)) return null;
   const db = new import_node_sqlite4.DatabaseSync(database, { readOnly: true, timeout: 5e3 });
   try {
     const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='collector_registry'").get();
@@ -6265,9 +6489,9 @@ function findCollectorInHubDatabase(paths, collectorId) {
 }
 function createLocalEnrollmentGrant(paths, host) {
   const database = hubDatabasePath(paths);
-  if (!(0, import_node_fs16.existsSync)(database)) throw new SystemError("hub-unavailable", "the hub database does not exist yet");
-  const token = (0, import_node_crypto11.randomBytes)(32).toString("base64url");
-  const tokenHash = (0, import_node_crypto11.createHash)("sha256").update(token).digest("hex");
+  if (!(0, import_node_fs17.existsSync)(database)) throw new SystemError("hub-unavailable", "the hub database does not exist yet");
+  const token = (0, import_node_crypto12.randomBytes)(32).toString("base64url");
+  const tokenHash = (0, import_node_crypto12.createHash)("sha256").update(token).digest("hex");
   const expiresAt = host.now() + 10 * 60 * 1e3;
   const db = new import_node_sqlite4.DatabaseSync(database, { timeout: 5e3 });
   try {
@@ -6319,7 +6543,7 @@ async function pairCollectorWithHub(options) {
       note: "the local hub has no reachable loopback or HTTPS destination"
     };
   }
-  if (!(0, import_node_fs16.existsSync)((0, import_node_path18.join)(paths.unitsDir, UNIT_NAMES.hub))) {
+  if (!(0, import_node_fs17.existsSync)((0, import_node_path19.join)(paths.unitsDir, UNIT_NAMES.hub))) {
     return { paired: false, awaiting: true, hubWasActive: false, note: "the local hub unit is not installed" };
   }
   const hubWasActive = systemdActive(host, UNIT_NAMES.hub);
@@ -6332,7 +6556,7 @@ async function pairCollectorWithHub(options) {
           destinations: [{ url: destination.url, token: registered.token, sharing: { ...SYSTEM_DEFAULT_SHARING } }]
         };
         writeCollectorIdentity(collectorStatePath2(paths), adopted);
-        chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
+        chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
         return { paired: true, awaiting: false, hubWasActive, destination: destination.url };
       }
     }
@@ -6340,7 +6564,7 @@ async function pairCollectorWithHub(options) {
     try {
       grant = createLocalEnrollmentGrant(paths, host);
     } catch (error2) {
-      chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
+      chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
       return {
         paired: false,
         awaiting: true,
@@ -6358,18 +6582,18 @@ async function pairCollectorWithHub(options) {
         note: `enrollment through the live hub failed: ${error2 instanceof Error ? error2.message : String(error2)}`
       };
     } finally {
-      chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
+      chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
     }
     if (!collectorConfigured(paths).configured) {
       return { paired: false, awaiting: true, hubWasActive, note: "the hub accepted enrollment but no destination was saved" };
     }
-    chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
+    chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
     return { paired: true, awaiting: false, hubWasActive, destination: destination.url };
   }
   const identity = {
-    collectorId: existing?.collectorId ?? (0, import_node_crypto11.randomUUID)(),
-    machineId: (0, import_node_crypto11.randomUUID)(),
-    token: (0, import_node_crypto11.randomBytes)(32).toString("base64url")
+    collectorId: existing?.collectorId ?? (0, import_node_crypto12.randomUUID)(),
+    machineId: (0, import_node_crypto12.randomUUID)(),
+    token: (0, import_node_crypto12.randomBytes)(32).toString("base64url")
   };
   const registry = registerCollectorInHubDatabase(paths, identity, host);
   let token = identity.token;
@@ -6396,7 +6620,7 @@ async function pairCollectorWithHub(options) {
     }
   ];
   writeCollectorIdentity(collectorStatePath2(paths), next);
-  chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
+  chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
   return { paired: true, awaiting: false, hubWasActive, destination: destination.url };
 }
 function unitCommon(name, description, paths, account, envPath, execStart, extraService = []) {
@@ -6413,7 +6637,7 @@ function unitCommon(name, description, paths, account, envPath, execStart, extra
     "Type=simple",
     `User=${account}`,
     `Group=${account}`,
-    `WorkingDirectory=${(0, import_node_path18.join)(paths.prefix, "current").replace(/%/g, "%%")}`,
+    `WorkingDirectory=${(0, import_node_path19.join)(paths.prefix, "current").replace(/%/g, "%%")}`,
     `EnvironmentFile=${envPath.replace(/%/g, "%%")}`,
     "Environment=NODE_ENV=production",
     "Restart=on-failure",
@@ -6448,13 +6672,13 @@ function unitCommon(name, description, paths, account, envPath, execStart, extra
 }
 function renderSystemHubUnit(options) {
   const { paths, accounts } = options;
-  const hubScript = (0, import_node_path18.join)(paths.prefix, "current", "dist", "hub.cjs");
+  const hubScript = (0, import_node_path19.join)(paths.prefix, "current", "dist", "hub.cjs");
   const extra = [
     `Environment=${systemdQuote(`HUB_DATABASE_PATH=${options.database}`)}`,
     `Environment=${systemdQuote(`HUB_STATE_FILE=${options.enrollment}`)}`,
     ...options.remote ? [`Environment=${systemdQuote(`HUB_SOCKET_PATH=${options.socket}`)}`] : [],
-    `ReadWritePaths=${systemdQuote((0, import_node_path18.join)(paths.stateDir, "hub"))}`,
-    `ReadOnlyPaths=${systemdQuote((0, import_node_path18.join)(paths.prefix, "current"))}`,
+    `ReadWritePaths=${systemdQuote((0, import_node_path19.join)(paths.stateDir, "hub"))}`,
+    `ReadOnlyPaths=${systemdQuote((0, import_node_path19.join)(paths.prefix, "current"))}`,
     "PrivateDevices=yes",
     "TimeoutStopSec=15s"
   ];
@@ -6473,14 +6697,14 @@ function renderSystemHubUnit(options) {
 }
 function renderSystemCollectorUnit(options) {
   const { paths, accounts } = options;
-  const collectorScript = (0, import_node_path18.join)(paths.prefix, "current", "dist", "collector.cjs");
+  const collectorScript = (0, import_node_path19.join)(paths.prefix, "current", "dist", "collector.cjs");
   const extra = [
     ...options.powerAccess ? [`SupplementaryGroups=${accounts.powerGroup}`] : [],
     `Environment=${systemdQuote(`COLLECTOR_MODE=real`)}`,
     `Environment=${systemdQuote(`COLLECTOR_STATE_FILE=${options.collectorState}`)}`,
-    `Environment=${systemdQuote(`COLLECTOR_HEALTH_FILE=${(0, import_node_path18.join)(paths.stateDir, "collector", "health.json")}`)}`,
-    `ReadWritePaths=${systemdQuote((0, import_node_path18.join)(paths.stateDir, "collector"))}`,
-    `ReadOnlyPaths=${systemdQuote((0, import_node_path18.join)(paths.prefix, "current"))}`,
+    `Environment=${systemdQuote(`COLLECTOR_HEALTH_FILE=${(0, import_node_path19.join)(paths.stateDir, "collector", "health.json")}`)}`,
+    `ReadWritePaths=${systemdQuote((0, import_node_path19.join)(paths.stateDir, "collector"))}`,
+    `ReadOnlyPaths=${systemdQuote((0, import_node_path19.join)(paths.prefix, "current"))}`,
     "TimeoutStopSec=10s"
   ];
   return [
@@ -6553,11 +6777,15 @@ function collectorEnvTemplate() {
     "# COLLECTOR_ENROLL_URL=ws://127.0.0.1:8081/api/collector/connect",
     "# COLLECTOR_ENROLL_TOKEN=<one-use grant>",
     "# COLLECTOR_MODE=real",
+    "# Unacknowledged samples wait in RAM by default: no queue is written to disk",
+    "# and a collector restart loses what was never acknowledged. Set this to durable",
+    "# to keep them in a per-hub SQLite outbox across collector restarts.",
+    "# COLLECTOR_QUEUE_MODE=durable",
     ""
   ].join("\n");
 }
 function assertPrivateSourceFile(path2, label3) {
-  const stat = (0, import_node_fs16.lstatSync)(path2);
+  const stat = (0, import_node_fs17.lstatSync)(path2);
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new SystemError("unsafe-adoption", `${label3} must be a regular file: ${path2}`);
   }
@@ -6568,7 +6796,7 @@ function assertPrivateSourceFile(path2, label3) {
 function readJsonObject(path2) {
   let raw;
   try {
-    raw = (0, import_node_fs16.readFileSync)(path2, "utf8");
+    raw = (0, import_node_fs17.readFileSync)(path2, "utf8");
   } catch (error2) {
     throw new SystemError("missing-file", `cannot read ${path2}: ${error2.message}`);
   }
@@ -6591,8 +6819,8 @@ function isCanonicalComponents(value) {
 }
 function readSystemState(paths) {
   const path2 = stateFilePath(paths);
-  if (!(0, import_node_fs16.existsSync)(path2)) return null;
-  const stat = (0, import_node_fs16.lstatSync)(path2);
+  if (!(0, import_node_fs17.existsSync)(path2)) return null;
+  const stat = (0, import_node_fs17.lstatSync)(path2);
   if (!stat.isFile() || stat.isSymbolicLink()) throw new SystemError("unsafe-path", `${path2} must be a regular file`);
   if ((stat.mode & 63) !== 0) throw new SystemError("insecure-permissions", `${path2} must be 0600`);
   const raw = readJsonObject(path2);
@@ -6624,7 +6852,7 @@ function readSystemState(paths) {
 }
 function systemStateIsLegacy(paths) {
   const path2 = stateFilePath(paths);
-  if (!(0, import_node_fs16.existsSync)(path2)) return false;
+  if (!(0, import_node_fs17.existsSync)(path2)) return false;
   let raw;
   try {
     raw = readJsonObject(path2);
@@ -6675,24 +6903,24 @@ function validateVersion2(value) {
   return value;
 }
 function releaseVersion(root) {
-  const metadata = readJsonObject((0, import_node_path18.join)(root, "package.json"));
+  const metadata = readJsonObject((0, import_node_path19.join)(root, "package.json"));
   if (Object.hasOwn(metadata, "rigscopeConfigVersion")) {
     throw new SystemError("invalid-release", "release uses unfinished configuration metadata; select a canonical release");
   }
   return validateVersion2(metadata.version);
 }
 function releaseSchemaVersion(root) {
-  const manifestPath = (0, import_node_path18.join)(root, "manifest.json");
-  if (!(0, import_node_fs16.existsSync)(manifestPath)) return null;
+  const manifestPath = (0, import_node_path19.join)(root, "manifest.json");
+  if (!(0, import_node_fs17.existsSync)(manifestPath)) return null;
   const manifest = readJsonObject(manifestPath);
   return Number.isSafeInteger(manifest.schemaVersion) ? Number(manifest.schemaVersion) : null;
 }
 function assertReleaseArtifacts(root) {
   for (const artifact of REQUIRED_ARTIFACTS) {
-    const path2 = (0, import_node_path18.join)(root, artifact);
+    const path2 = (0, import_node_path19.join)(root, artifact);
     let stat;
     try {
-      stat = (0, import_node_fs16.lstatSync)(path2);
+      stat = (0, import_node_fs17.lstatSync)(path2);
     } catch {
       throw new SystemError("missing-artifact", `release is missing ${artifact}`);
     }
@@ -6700,12 +6928,12 @@ function assertReleaseArtifacts(root) {
       throw new SystemError("invalid-artifact", `release artifact is not a non-empty regular file: ${artifact}`);
     }
   }
-  const buildId = (0, import_node_fs16.readFileSync)((0, import_node_path18.join)(root, ".next", "BUILD_ID"), "utf8").trim();
+  const buildId = (0, import_node_fs17.readFileSync)((0, import_node_path19.join)(root, ".next", "BUILD_ID"), "utf8").trim();
   if (buildId === "" || /\s/.test(buildId)) throw new SystemError("invalid-artifact", ".next/BUILD_ID is invalid");
   for (const directory of [".next/server", ".next/static"]) {
     let stat;
     try {
-      stat = (0, import_node_fs16.lstatSync)((0, import_node_path18.join)(root, directory));
+      stat = (0, import_node_fs17.lstatSync)((0, import_node_path19.join)(root, directory));
     } catch {
       throw new SystemError("missing-artifact", `release is missing ${directory}/`);
     }
@@ -6713,10 +6941,10 @@ function assertReleaseArtifacts(root) {
   }
 }
 function verifyReleaseManifest(root) {
-  const manifestPath = (0, import_node_path18.join)(root, "manifest.json");
-  if (!(0, import_node_fs16.existsSync)(manifestPath)) return;
+  const manifestPath = (0, import_node_path19.join)(root, "manifest.json");
+  if (!(0, import_node_fs17.existsSync)(manifestPath)) return;
   const manifest = readJsonObject(manifestPath);
-  const packageJson = readJsonObject((0, import_node_path18.join)(root, "package.json"));
+  const packageJson = readJsonObject((0, import_node_path19.join)(root, "package.json"));
   if (manifest.name !== void 0 && manifest.name !== packageJson.name) {
     throw new SystemError("manifest-mismatch", "release manifest name does not match package.json");
   }
@@ -6735,17 +6963,17 @@ function verifyReleaseManifest(root) {
     if (typeof relativePath !== "string" || relativePath === "" || relativePath.startsWith("/") || relativePath.includes("\\") || relativePath.split("/").includes("..")) {
       throw new SystemError("invalid-manifest", `release manifest contains an unsafe path: ${String(relativePath)}`);
     }
-    const absolute = (0, import_node_path18.join)(root, relativePath);
-    const stat = (0, import_node_fs16.lstatSync)(absolute);
+    const absolute = (0, import_node_path19.join)(root, relativePath);
+    const stat = (0, import_node_fs17.lstatSync)(absolute);
     if (!stat.isFile() || stat.isSymbolicLink()) throw new SystemError("invalid-manifest", `release artifact is not a regular file: ${relativePath}`);
     if (entry2.bytes !== stat.size) throw new SystemError("artifact-mismatch", `release artifact size changed: ${relativePath}`);
     if (entry2.sha256 !== sha256File2(absolute)) throw new SystemError("artifact-mismatch", `release artifact hash changed: ${relativePath}`);
     listed.add(relativePath);
   }
   const visit = (current) => {
-    for (const entry2 of (0, import_node_fs16.readdirSync)(current, { withFileTypes: true })) {
-      const absolute = (0, import_node_path18.join)(current, entry2.name);
-      const rel = (0, import_node_path18.relative)(root, absolute).split(import_node_path18.sep).join("/");
+    for (const entry2 of (0, import_node_fs17.readdirSync)(current, { withFileTypes: true })) {
+      const absolute = (0, import_node_path19.join)(current, entry2.name);
+      const rel = (0, import_node_path19.relative)(root, absolute).split(import_node_path19.sep).join("/");
       if (rel === "node_modules" || rel.startsWith("node_modules/") || rel === ".next/cache" || rel.startsWith(".next/cache/")) continue;
       if (entry2.isSymbolicLink()) throw new SystemError("unsafe-release", `release contains a symlink: ${rel}`);
       if (entry2.isDirectory()) {
@@ -6760,49 +6988,49 @@ function verifyReleaseManifest(root) {
 }
 function assertNoSymlinks(root) {
   const visit = (path2) => {
-    const stat = (0, import_node_fs16.lstatSync)(path2);
-    if (stat.isSymbolicLink()) throw new SystemError("unsafe-release", `release contains a symlink: ${(0, import_node_path18.relative)(root, path2)}`);
+    const stat = (0, import_node_fs17.lstatSync)(path2);
+    if (stat.isSymbolicLink()) throw new SystemError("unsafe-release", `release contains a symlink: ${(0, import_node_path19.relative)(root, path2)}`);
     if (!stat.isDirectory()) return;
-    for (const entry2 of (0, import_node_fs16.readdirSync)(path2)) visit((0, import_node_path18.join)(path2, entry2));
+    for (const entry2 of (0, import_node_fs17.readdirSync)(path2)) visit((0, import_node_path19.join)(path2, entry2));
   };
   visit(root);
 }
 function copyReleaseTree(source, destination) {
   const visit = (current, target) => {
-    const stat = (0, import_node_fs16.lstatSync)(current);
-    if (stat.isSymbolicLink()) throw new SystemError("unsafe-release", `source contains a symlink: ${(0, import_node_path18.relative)(source, current)}`);
+    const stat = (0, import_node_fs17.lstatSync)(current);
+    if (stat.isSymbolicLink()) throw new SystemError("unsafe-release", `source contains a symlink: ${(0, import_node_path19.relative)(source, current)}`);
     if (stat.isDirectory()) {
-      (0, import_node_fs16.mkdirSync)(target, { recursive: true, mode: 493 });
-      for (const entry2 of (0, import_node_fs16.readdirSync)(current)) {
-        const child = (0, import_node_path18.join)(current, entry2);
-        const rel = (0, import_node_path18.relative)(source, child);
+      (0, import_node_fs17.mkdirSync)(target, { recursive: true, mode: 493 });
+      for (const entry2 of (0, import_node_fs17.readdirSync)(current)) {
+        const child = (0, import_node_path19.join)(current, entry2);
+        const rel = (0, import_node_path19.relative)(source, child);
         if (rel === ".git" || rel === ".next-dev" || rel === ".next/cache" || rel === "node_modules" || rel.startsWith("node_modules/")) {
           continue;
         }
-        visit(child, (0, import_node_path18.join)(target, entry2));
+        visit(child, (0, import_node_path19.join)(target, entry2));
       }
       return;
     }
-    if (!stat.isFile()) throw new SystemError("unsafe-release", `source contains a non-regular file: ${(0, import_node_path18.relative)(source, current)}`);
-    (0, import_node_fs16.mkdirSync)((0, import_node_path18.dirname)(target), { recursive: true, mode: 493 });
-    (0, import_node_fs16.copyFileSync)(current, target);
-    (0, import_node_fs16.chmodSync)(target, 420);
+    if (!stat.isFile()) throw new SystemError("unsafe-release", `source contains a non-regular file: ${(0, import_node_path19.relative)(source, current)}`);
+    (0, import_node_fs17.mkdirSync)((0, import_node_path19.dirname)(target), { recursive: true, mode: 493 });
+    (0, import_node_fs17.copyFileSync)(current, target);
+    (0, import_node_fs17.chmodSync)(target, 420);
   };
   visit(source, destination);
 }
 function copyReleaseAllowlisted(source, destination) {
-  for (const entry2 of (0, import_node_fs16.readdirSync)(source)) {
+  for (const entry2 of (0, import_node_fs17.readdirSync)(source)) {
     if (!PACKAGE_TOP_LEVEL.has(entry2)) continue;
     if (entry2 === "node_modules") continue;
-    const child = (0, import_node_path18.join)(source, entry2);
-    const target = (0, import_node_path18.join)(destination, entry2);
-    const stat = (0, import_node_fs16.lstatSync)(child);
+    const child = (0, import_node_path19.join)(source, entry2);
+    const target = (0, import_node_path19.join)(destination, entry2);
+    const stat = (0, import_node_fs17.lstatSync)(child);
     if (stat.isSymbolicLink()) throw new SystemError("unsafe-release", `source contains a symlink: ${entry2}`);
     if (stat.isDirectory()) {
       copyReleaseTree(child, target);
     } else if (stat.isFile()) {
-      (0, import_node_fs16.copyFileSync)(child, target);
-      (0, import_node_fs16.chmodSync)(target, 420);
+      (0, import_node_fs17.copyFileSync)(child, target);
+      (0, import_node_fs17.chmodSync)(target, 420);
     }
   }
 }
@@ -6837,28 +7065,28 @@ function extractArchive(archive, stage, host) {
 }
 function discardStagedRelease(staged) {
   if (staged === null) return;
-  (0, import_node_fs16.rmSync)(staged.stageDir, { recursive: true, force: true });
+  (0, import_node_fs17.rmSync)(staged.stageDir, { recursive: true, force: true });
 }
 function releaseTargetDir(paths, version) {
-  return (0, import_node_path18.join)(paths.prefix, "releases", version);
+  return (0, import_node_path19.join)(paths.prefix, "releases", version);
 }
 function assertReleaseTargetAvailable(paths, releaseDir, replaceRelease) {
-  if (!(0, import_node_fs16.existsSync)(releaseDir)) return;
+  if (!(0, import_node_fs17.existsSync)(releaseDir)) return;
   const current = currentReleaseDir(paths);
   const previous = previousReleaseDir(paths);
   if (!replaceRelease || current === releaseDir || previous === releaseDir) {
     throw new SystemError(
       "release-exists",
-      `release ${(0, import_node_path18.basename)(releaseDir)} is already installed${current === releaseDir || previous === releaseDir ? " or retained" : ""}; choose a new version`
+      `release ${(0, import_node_path19.basename)(releaseDir)} is already installed${current === releaseDir || previous === releaseDir ? " or retained" : ""}; choose a new version`
     );
   }
 }
 function stageRelease(options) {
-  const source = (0, import_node_fs16.realpathSync)((0, import_node_path18.resolve)(options.source));
-  const stat = (0, import_node_fs16.lstatSync)(source);
+  const source = (0, import_node_fs17.realpathSync)((0, import_node_path19.resolve)(options.source));
+  const stat = (0, import_node_fs17.lstatSync)(source);
   ensureDirectory(options.paths.prefix, 493);
-  const stageDir = (0, import_node_path18.join)(options.paths.prefix, `.stage-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  (0, import_node_fs16.mkdirSync)(stageDir, { recursive: true, mode: 448 });
+  const stageDir = (0, import_node_path19.join)(options.paths.prefix, `.stage-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  (0, import_node_fs17.mkdirSync)(stageDir, { recursive: true, mode: 448 });
   try {
     if (stat.isDirectory() && !stat.isSymbolicLink()) {
       copyReleaseAllowlisted(source, stageDir);
@@ -6876,7 +7104,7 @@ function stageRelease(options) {
       artifacts: [...REQUIRED_ARTIFACTS]
     };
   } catch (error2) {
-    (0, import_node_fs16.rmSync)(stageDir, { recursive: true, force: true });
+    (0, import_node_fs17.rmSync)(stageDir, { recursive: true, force: true });
     throw error2;
   }
 }
@@ -6902,13 +7130,13 @@ function prepareStagedRelease(options) {
   }
 }
 function commitStagedRelease(options) {
-  const releasesDir = (0, import_node_path18.join)(options.paths.prefix, "releases");
+  const releasesDir = (0, import_node_path19.join)(options.paths.prefix, "releases");
   ensureDirectory(releasesDir, 493);
   const releaseDir = releaseTargetDir(options.paths, options.staged.version);
   assertReleaseTargetAvailable(options.paths, releaseDir, options.replaceRelease);
-  if ((0, import_node_fs16.existsSync)(releaseDir)) (0, import_node_fs16.rmSync)(releaseDir, { recursive: true, force: true });
-  (0, import_node_fs16.renameSync)(options.staged.stageDir, releaseDir);
-  ensureDirectory((0, import_node_path18.join)(releaseDir, ".next", "cache"), 493);
+  if ((0, import_node_fs17.existsSync)(releaseDir)) (0, import_node_fs17.rmSync)(releaseDir, { recursive: true, force: true });
+  (0, import_node_fs17.renameSync)(options.staged.stageDir, releaseDir);
+  ensureDirectory((0, import_node_path19.join)(releaseDir, ".next", "cache"), 493);
   return {
     version: options.staged.version,
     releaseDir,
@@ -6917,20 +7145,20 @@ function commitStagedRelease(options) {
   };
 }
 function dependencyNames(root) {
-  const pkg = readJsonObject((0, import_node_path18.join)(root, "package.json"));
+  const pkg = readJsonObject((0, import_node_path19.join)(root, "package.json"));
   const dependencies2 = pkg.dependencies;
   if (dependencies2 === null || typeof dependencies2 !== "object" || Array.isArray(dependencies2)) return [];
   return Object.keys(dependencies2).filter((name) => /^[A-Za-z0-9@/._-]+$/.test(name));
 }
 function missingDependencies(root) {
-  return dependencyNames(root).filter((name) => !(0, import_node_fs16.existsSync)((0, import_node_path18.join)(root, "node_modules", name, "package.json")));
+  return dependencyNames(root).filter((name) => !(0, import_node_fs17.existsSync)((0, import_node_path19.join)(root, "node_modules", name, "package.json")));
 }
 function installDependencies(root, host, command = "npm") {
-  const hasLock = (0, import_node_fs16.existsSync)((0, import_node_path18.join)(root, "package-lock.json"));
+  const hasLock = (0, import_node_fs17.existsSync)((0, import_node_path19.join)(root, "package-lock.json"));
   const args = hasLock ? ["ci", "--omit=dev", "--ignore-scripts", "--no-audit", "--no-fund"] : ["install", "--omit=dev", "--ignore-scripts", "--no-audit", "--no-fund"];
-  const siblingNpm = (0, import_node_path18.join)((0, import_node_path18.dirname)(process.execPath), "npm");
-  const executable = command === "npm" && (0, import_node_fs16.existsSync)(siblingNpm) ? siblingNpm : command;
-  const nodeBin = (0, import_node_path18.dirname)(process.execPath);
+  const siblingNpm = (0, import_node_path19.join)((0, import_node_path19.dirname)(process.execPath), "npm");
+  const executable = command === "npm" && (0, import_node_fs17.existsSync)(siblingNpm) ? siblingNpm : command;
+  const nodeBin = (0, import_node_path19.dirname)(process.execPath);
   const path2 = [nodeBin, process.env.PATH ?? ""].filter(Boolean).join(":");
   runRequired(host, executable, args, "production dependency installation", {
     cwd: root,
@@ -6939,21 +7167,21 @@ function installDependencies(root, host, command = "npm") {
   });
 }
 function currentReleaseDir(paths) {
-  const link = (0, import_node_path18.join)(paths.prefix, "current");
+  const link = (0, import_node_path19.join)(paths.prefix, "current");
   try {
-    const target = (0, import_node_fs16.readlinkSync)(link);
-    const absolute = (0, import_node_path18.isAbsolute)(target) ? target : (0, import_node_path18.resolve)(paths.prefix, target);
-    return isWithin((0, import_node_path18.join)(paths.prefix, "releases"), absolute) ? absolute : null;
+    const target = (0, import_node_fs17.readlinkSync)(link);
+    const absolute = (0, import_node_path19.isAbsolute)(target) ? target : (0, import_node_path19.resolve)(paths.prefix, target);
+    return isWithin((0, import_node_path19.join)(paths.prefix, "releases"), absolute) ? absolute : null;
   } catch {
     return null;
   }
 }
 function previousReleaseDir(paths) {
-  const link = (0, import_node_path18.join)(paths.prefix, "previous");
+  const link = (0, import_node_path19.join)(paths.prefix, "previous");
   try {
-    const target = (0, import_node_fs16.readlinkSync)(link);
-    const absolute = (0, import_node_path18.isAbsolute)(target) ? target : (0, import_node_path18.resolve)(paths.prefix, target);
-    return isWithin((0, import_node_path18.join)(paths.prefix, "releases"), absolute) ? absolute : null;
+    const target = (0, import_node_fs17.readlinkSync)(link);
+    const absolute = (0, import_node_path19.isAbsolute)(target) ? target : (0, import_node_path19.resolve)(paths.prefix, target);
+    return isWithin((0, import_node_path19.join)(paths.prefix, "releases"), absolute) ? absolute : null;
   } catch {
     return null;
   }
@@ -6961,11 +7189,11 @@ function previousReleaseDir(paths) {
 function replaceSymlink(link, target, host) {
   const temporary = `${link}.tmp-${process.pid}-${Date.now()}`;
   try {
-    (0, import_node_fs16.symlinkSync)(target, temporary);
-    (0, import_node_fs16.renameSync)(temporary, link);
+    (0, import_node_fs17.symlinkSync)(target, temporary);
+    (0, import_node_fs17.renameSync)(temporary, link);
   } catch (error2) {
     try {
-      (0, import_node_fs16.unlinkSync)(temporary);
+      (0, import_node_fs17.unlinkSync)(temporary);
     } catch {
     }
     throw error2;
@@ -6974,8 +7202,8 @@ function replaceSymlink(link, target, host) {
 }
 function removeSymlink(link) {
   try {
-    const stat = (0, import_node_fs16.lstatSync)(link);
-    if (stat.isSymbolicLink()) (0, import_node_fs16.unlinkSync)(link);
+    const stat = (0, import_node_fs17.lstatSync)(link);
+    if (stat.isSymbolicLink()) (0, import_node_fs17.unlinkSync)(link);
   } catch {
   }
 }
@@ -6988,18 +7216,18 @@ function nodeVersion(host, nodePath) {
   return output;
 }
 function ensureRootOwnedNode(options) {
-  const selected = (0, import_node_path18.resolve)(options.nodePath ?? process.execPath);
-  const real = (0, import_node_fs16.realpathSync)(selected);
+  const selected = (0, import_node_path19.resolve)(options.nodePath ?? process.execPath);
+  const real = (0, import_node_fs17.realpathSync)(selected);
   nodeVersion(options.host, real);
-  const stat = (0, import_node_fs16.statSync)(real);
-  const insideRelease = isWithin((0, import_node_path18.join)(options.paths.prefix, "releases"), real);
+  const stat = (0, import_node_fs17.statSync)(real);
+  const insideRelease = isWithin((0, import_node_path19.join)(options.paths.prefix, "releases"), real);
   const unsafe = stat.uid !== 0 || (stat.mode & 18) !== 0 || options.copyNode === true || insideRelease;
   if (!unsafe || options.trustedNode === true) return real;
-  const target = (0, import_node_path18.join)(options.paths.prefix, "node", "node");
+  const target = (0, import_node_path19.join)(options.paths.prefix, "node", "node");
   if (!options.apply) return target;
-  ensureDirectory((0, import_node_path18.join)(options.paths.prefix, "node"), 493);
-  (0, import_node_fs16.copyFileSync)(real, target);
-  (0, import_node_fs16.chmodSync)(target, 493);
+  ensureDirectory((0, import_node_path19.join)(options.paths.prefix, "node"), 493);
+  (0, import_node_fs17.copyFileSync)(real, target);
+  (0, import_node_fs17.chmodSync)(target, 493);
   runRequired(options.host, "chown", ["root:root", target], "node ownership");
   nodeVersion(options.host, target);
   return target;
@@ -7028,8 +7256,8 @@ function validatedOrigin(value) {
   return value;
 }
 function readAdoptionSetup(source) {
-  const configPath = (0, import_node_path18.join)(source, "config.json");
-  if (!(0, import_node_fs16.existsSync)(configPath)) {
+  const configPath = (0, import_node_path19.join)(source, "config.json");
+  if (!(0, import_node_fs17.existsSync)(configPath)) {
     throw new SystemError("invalid-adoption", "adopted installation has no config.json");
   }
   assertPrivateSourceFile(configPath, "adopted setup");
@@ -7077,35 +7305,35 @@ function detectUserInstallations(options = {}) {
   const roots = options.homeRoots ?? ["/home", "/root"];
   const found = [];
   for (const homeRoot of roots) {
-    if (!(0, import_node_fs16.existsSync)(homeRoot)) continue;
-    const homes = homeRoot === "/root" ? ["/root"] : (0, import_node_fs16.readdirSync)(homeRoot).map((entry2) => (0, import_node_path18.join)(homeRoot, entry2));
+    if (!(0, import_node_fs17.existsSync)(homeRoot)) continue;
+    const homes = homeRoot === "/root" ? ["/root"] : (0, import_node_fs17.readdirSync)(homeRoot).map((entry2) => (0, import_node_path19.join)(homeRoot, entry2));
     for (const home of homes) {
       let stat;
       try {
-        stat = (0, import_node_fs16.lstatSync)(home);
+        stat = (0, import_node_fs17.lstatSync)(home);
       } catch {
         continue;
       }
       if (!stat.isDirectory()) continue;
-      const unitDir = (0, import_node_path18.join)(home, ".config", "systemd", "user");
+      const unitDir = (0, import_node_path19.join)(home, ".config", "systemd", "user");
       let units = [];
       try {
-        units = (0, import_node_fs16.readdirSync)(unitDir);
+        units = (0, import_node_fs17.readdirSync)(unitDir);
       } catch {
         units = [];
       }
       for (const unitName2 of units) {
         if (!/^rigscope(?:-[0-9a-f]{12})?(?:-(?:hub|collector))?\.service$/.test(unitName2)) continue;
-        const unitPath2 = (0, import_node_path18.join)(unitDir, unitName2);
+        const unitPath2 = (0, import_node_path19.join)(unitDir, unitName2);
         let execStart = null;
         try {
-          const line = (0, import_node_fs16.readFileSync)(unitPath2, "utf8").split("\n").find((item) => item.startsWith("ExecStart="));
+          const line = (0, import_node_fs17.readFileSync)(unitPath2, "utf8").split("\n").find((item) => item.startsWith("ExecStart="));
           execStart = line ? line.slice("ExecStart=".length) : null;
         } catch {
         }
-        const stateCandidates = [(0, import_node_path18.join)(home, ".local", "state", "rigscope")];
-        const stateDir = stateCandidates.find((candidate) => (0, import_node_fs16.existsSync)(candidate)) ?? null;
-        found.push({ user: (0, import_node_path18.basename)(home), home, unitPath: unitPath2, unitName: unitName2, execStart, stateDir });
+        const stateCandidates = [(0, import_node_path19.join)(home, ".local", "state", "rigscope")];
+        const stateDir = stateCandidates.find((candidate) => (0, import_node_fs17.existsSync)(candidate)) ?? null;
+        found.push({ user: (0, import_node_path19.basename)(home), home, unitPath: unitPath2, unitName: unitName2, execStart, stateDir });
       }
     }
   }
@@ -7113,9 +7341,9 @@ function detectUserInstallations(options = {}) {
 }
 function lockIsLive(path2) {
   try {
-    const stat = (0, import_node_fs16.lstatSync)(path2);
+    const stat = (0, import_node_fs17.lstatSync)(path2);
     if (!stat.isFile() || stat.size > 4096) return { exists: true, live: false, pid: null, ambiguous: true };
-    const owner = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
+    const owner = JSON.parse((0, import_node_fs17.readFileSync)(path2, "utf8"));
     const pid = owner.pid;
     if (!Number.isSafeInteger(pid) || pid < 1) return { exists: true, live: false, pid: null, ambiguous: true };
     try {
@@ -7133,9 +7361,9 @@ function lockIsLive(path2) {
 }
 function directoryLocks(directory) {
   return [
-    (0, import_node_path18.join)(directory, "hub", "telemetry.sqlite.hub.lock"),
-    (0, import_node_path18.join)(directory, "run", "rigscope.lock"),
-    (0, import_node_path18.join)(directory, "collector", "collector-runtime.lock")
+    (0, import_node_path19.join)(directory, "hub", "telemetry.sqlite.hub.lock"),
+    (0, import_node_path19.join)(directory, "run", "rigscope.lock"),
+    (0, import_node_path19.join)(directory, "collector", "collector-runtime.lock")
   ];
 }
 function assertDirectoryStopped(directory, scope = "local") {
@@ -7166,13 +7394,13 @@ function assertSystemStartAllowed(paths, components) {
 }
 function detectPowerDriver(moduleRoot = "/sys/module") {
   const candidates = ["intel_rapl_msr", "intel_rapl_common", "intel_rapl_tpmi", "intel_rapl", "amd_energy"];
-  return candidates.filter((name) => (0, import_node_fs16.existsSync)((0, import_node_path18.join)(moduleRoot, name)));
+  return candidates.filter((name) => (0, import_node_fs17.existsSync)((0, import_node_path19.join)(moduleRoot, name)));
 }
 function readPasswd(path2 = "/etc/passwd") {
   const users = /* @__PURE__ */ new Map();
   let lines;
   try {
-    lines = (0, import_node_fs16.readFileSync)(path2, "utf8").split("\n");
+    lines = (0, import_node_fs17.readFileSync)(path2, "utf8").split("\n");
   } catch {
     return users;
   }
@@ -7189,7 +7417,7 @@ function readGroups(path2 = "/etc/group") {
   const groups = /* @__PURE__ */ new Map();
   let lines;
   try {
-    lines = (0, import_node_fs16.readFileSync)(path2, "utf8").split("\n");
+    lines = (0, import_node_fs17.readFileSync)(path2, "utf8").split("\n");
   } catch {
     return groups;
   }
@@ -7217,7 +7445,7 @@ function inspectPowerAccess(options = {}) {
   const sysusers = options.sysusersPath ?? powerSysusersPath(paths);
   let ruleText = null;
   try {
-    ruleText = (0, import_node_fs16.readFileSync)(rulePath, "utf8");
+    ruleText = (0, import_node_fs17.readFileSync)(rulePath, "utf8");
   } catch {
     ruleText = null;
   }
@@ -7234,27 +7462,27 @@ function inspectPowerAccess(options = {}) {
   const domains = [];
   let entries = [];
   try {
-    entries = (0, import_node_fs16.readdirSync)(paths.powercapRoot);
+    entries = (0, import_node_fs17.readdirSync)(paths.powercapRoot);
   } catch {
     entries = [];
   }
   for (const entry2 of entries.filter((name) => /^intel-rapl:\d+$/.test(name)).sort()) {
-    const domainPath = (0, import_node_path18.join)(paths.powercapRoot, entry2);
+    const domainPath = (0, import_node_path19.join)(paths.powercapRoot, entry2);
     let name = entry2;
     try {
-      name = (0, import_node_fs16.readFileSync)((0, import_node_path18.join)(domainPath, "name"), "utf8").trim() || entry2;
+      name = (0, import_node_fs17.readFileSync)((0, import_node_path19.join)(domainPath, "name"), "utf8").trim() || entry2;
     } catch {
     }
     if (!/^package/.test(name)) continue;
-    const energyPath = (0, import_node_path18.join)(domainPath, "energy_uj");
-    const maxRangePath = (0, import_node_path18.join)(domainPath, "max_energy_range_uj");
+    const energyPath = (0, import_node_path19.join)(domainPath, "energy_uj");
+    const maxRangePath = (0, import_node_path19.join)(domainPath, "max_energy_range_uj");
     const readStat = (path2) => {
       if (options.statOverride) {
         const override = options.statOverride(path2);
         return override === null ? null : { mode: modeString(override.mode), uid: override.uid, gid: override.gid };
       }
       try {
-        const stat = (0, import_node_fs16.statSync)(path2);
+        const stat = (0, import_node_fs17.statSync)(path2);
         return { mode: modeString(stat.mode), uid: stat.uid, gid: stat.gid };
       } catch {
         return null;
@@ -7288,7 +7516,7 @@ function inspectPowerAccess(options = {}) {
     problems.push(`collector account ${accounts.collector} is not a member of ${accounts.powerGroup}`);
   }
   if (!compliant) problems.push(`persistent udev rule is missing or not compliant: ${rulePath}`);
-  if (!(0, import_node_fs16.existsSync)(sysusers)) problems.push(`power sysusers definition is missing: ${sysusers}`);
+  if (!(0, import_node_fs17.existsSync)(sysusers)) problems.push(`power sysusers definition is missing: ${sysusers}`);
   for (const domain of domains) {
     if (!domain.energyExists) problems.push(`${domain.name}: energy_uj is unavailable`);
     else if (domain.energy?.worldReadable) problems.push(`${domain.name}: energy_uj is world-readable`);
@@ -7307,7 +7535,7 @@ function inspectPowerAccess(options = {}) {
     collectorGids,
     group: { name: accounts.powerGroup, exists: group !== null, gid: group?.gid ?? null, members: group?.members ?? [] },
     rule: { path: rulePath, present: ruleText !== null, compliant },
-    sysusers: { path: sysusers, present: (0, import_node_fs16.existsSync)(sysusers) },
+    sysusers: { path: sysusers, present: (0, import_node_fs17.existsSync)(sysusers) },
     collectorCanRead,
     persistent: compliant && group !== null && collector !== null && group.members.includes(accounts.collector),
     worldReadable,
@@ -7316,14 +7544,14 @@ function inspectPowerAccess(options = {}) {
   };
 }
 async function backupDatabase2(source, output, host) {
-  ensureDirectory((0, import_node_path18.dirname)(output), 448, true);
+  ensureDirectory((0, import_node_path19.dirname)(output), 448, true);
   const db = new import_node_sqlite4.DatabaseSync(source, { readOnly: true, timeout: 5e3 });
   try {
     await (0, import_node_sqlite4.backup)(db, output);
   } finally {
     db.close();
   }
-  (0, import_node_fs16.chmodSync)(output, 384);
+  (0, import_node_fs17.chmodSync)(output, 384);
   const check = new import_node_sqlite4.DatabaseSync(output, { readOnly: true });
   try {
     const result = check.prepare("PRAGMA integrity_check").get();
@@ -7334,7 +7562,7 @@ async function backupDatabase2(source, output, host) {
   void host;
 }
 function databaseSchema(path2) {
-  if (!(0, import_node_fs16.existsSync)(path2)) return null;
+  if (!(0, import_node_fs17.existsSync)(path2)) return null;
   const db = new import_node_sqlite4.DatabaseSync(path2, { readOnly: true, timeout: 5e3 });
   try {
     const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_migrations'").get();
@@ -7353,28 +7581,28 @@ function replaceDatabaseFromBackup(backupPath, target, safetyBackup, host) {
   } finally {
     backup3.close();
   }
-  ensureDirectory((0, import_node_path18.dirname)(target), 448, true);
-  if (safetyBackup !== null && (0, import_node_fs16.existsSync)(target)) {
+  ensureDirectory((0, import_node_path19.dirname)(target), 448, true);
+  if (safetyBackup !== null && (0, import_node_fs17.existsSync)(target)) {
     void host;
   }
-  const temporary = (0, import_node_path18.join)((0, import_node_path18.dirname)(target), `.restore-${process.pid}-${Date.now()}.sqlite`);
-  (0, import_node_fs16.copyFileSync)(backupPath, temporary);
-  (0, import_node_fs16.chmodSync)(temporary, 384);
+  const temporary = (0, import_node_path19.join)((0, import_node_path19.dirname)(target), `.restore-${process.pid}-${Date.now()}.sqlite`);
+  (0, import_node_fs17.copyFileSync)(backupPath, temporary);
+  (0, import_node_fs17.chmodSync)(temporary, 384);
   for (const sidecar of [`${target}-wal`, `${target}-shm`]) {
     try {
-      (0, import_node_fs16.unlinkSync)(sidecar);
+      (0, import_node_fs17.unlinkSync)(sidecar);
     } catch {
     }
   }
-  (0, import_node_fs16.renameSync)(temporary, target);
-  (0, import_node_fs16.chmodSync)(target, 384);
+  (0, import_node_fs17.renameSync)(temporary, target);
+  (0, import_node_fs17.chmodSync)(target, 384);
 }
 function newestTimestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function adoptUserState(options) {
-  const source = (0, import_node_path18.resolve)(options.source);
-  if (!(0, import_node_fs16.existsSync)(source)) throw new SystemError("invalid-adoption", `user installation does not exist: ${source}`);
+  const source = (0, import_node_path19.resolve)(options.source);
+  if (!(0, import_node_fs17.existsSync)(source)) throw new SystemError("invalid-adoption", `user installation does not exist: ${source}`);
   if (isWithin(options.paths.prefix, source) || isWithin(options.paths.stateDir, source) || isWithin(source, options.paths.stateDir)) {
     throw new SystemError("invalid-adoption", "adoption source and system paths must not overlap");
   }
@@ -7384,8 +7612,8 @@ function adoptUserState(options) {
   const { port, origin } = setup;
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new SystemError("invalid-adoption", "adopted hub port is invalid");
   if (options.role !== "collector") {
-    const sourceDatabase = (0, import_node_path18.join)(source, "hub", "telemetry.sqlite");
-    if ((0, import_node_fs16.existsSync)(sourceDatabase)) {
+    const sourceDatabase = (0, import_node_path19.join)(source, "hub", "telemetry.sqlite");
+    if ((0, import_node_fs17.existsSync)(sourceDatabase)) {
       assertPrivateSourceFile(sourceDatabase, "adopted database");
       const database = new import_node_sqlite4.DatabaseSync(sourceDatabase, { readOnly: true });
       try {
@@ -7395,12 +7623,12 @@ function adoptUserState(options) {
         database.close();
       }
     }
-    const sourceEnrollment = (0, import_node_path18.join)(source, "hub", "enrollment.json");
-    if ((0, import_node_fs16.existsSync)(sourceEnrollment)) assertPrivateSourceFile(sourceEnrollment, "adopted enrollment");
+    const sourceEnrollment = (0, import_node_path19.join)(source, "hub", "enrollment.json");
+    if ((0, import_node_fs17.existsSync)(sourceEnrollment)) assertPrivateSourceFile(sourceEnrollment, "adopted enrollment");
   }
   if (options.role !== "hub") {
-    const sourceCollectorState = (0, import_node_path18.join)(source, "collector", "state.json");
-    if ((0, import_node_fs16.existsSync)(sourceCollectorState)) {
+    const sourceCollectorState = (0, import_node_path19.join)(source, "collector", "state.json");
+    if ((0, import_node_fs17.existsSync)(sourceCollectorState)) {
       assertPrivateSourceFile(sourceCollectorState, "adopted collector state");
       readCollectorIdentity(sourceCollectorState);
     }
@@ -7409,7 +7637,7 @@ function adoptUserState(options) {
   const warnings = [];
   const targetDatabase = hubDatabasePath(options.paths);
   const targetCollector = collectorStatePath2(options.paths);
-  if (options.apply && (0, import_node_fs16.existsSync)(targetDatabase)) {
+  if (options.apply && (0, import_node_fs17.existsSync)(targetDatabase)) {
     throw new SystemError("destination-exists", `refusing to overwrite ${targetDatabase}`);
   }
   const hubEnv = options.role === "collector" ? null : [
@@ -7444,62 +7672,42 @@ function adoptUserState(options) {
     port
   };
 }
-function copyAdoptedTree(source, target, copied, skipLocks = true) {
-  const visit = (current, destination) => {
-    const stat = (0, import_node_fs16.lstatSync)(current);
-    if (stat.isSymbolicLink()) return;
-    if (stat.isDirectory()) {
-      (0, import_node_fs16.mkdirSync)(destination, { recursive: true, mode: 448 });
-      for (const entry2 of (0, import_node_fs16.readdirSync)(current)) visit((0, import_node_path18.join)(current, entry2), (0, import_node_path18.join)(destination, entry2));
-      return;
-    }
-    if (!stat.isFile()) return;
-    if (skipLocks && /\.(lock|sock)$/.test(current)) return;
-    (0, import_node_fs16.mkdirSync)((0, import_node_path18.dirname)(destination), { recursive: true, mode: 448 });
-    (0, import_node_fs16.copyFileSync)(current, destination);
-    (0, import_node_fs16.chmodSync)(destination, 384);
-    copied.push({ source: current, target: destination, sha256: sha256File2(destination), bytes: stat.size });
-  };
-  visit(source, target);
-}
 async function performAdoptionCopyAsync(options) {
   const { source, paths, role, host, copy } = options;
   assertDirectoryStopped(source, role);
   const targetDatabase = hubDatabasePath(paths);
-  const sourceDatabase = (0, import_node_path18.join)(source, "hub", "telemetry.sqlite");
-  if (role !== "collector" && (0, import_node_fs16.existsSync)(sourceDatabase) && !(0, import_node_fs16.existsSync)(targetDatabase)) {
+  const sourceDatabase = (0, import_node_path19.join)(source, "hub", "telemetry.sqlite");
+  if (role !== "collector" && (0, import_node_fs17.existsSync)(sourceDatabase) && !(0, import_node_fs17.existsSync)(targetDatabase)) {
     assertPrivateSourceFile(sourceDatabase, "adopted database");
-    ensureDirectory((0, import_node_path18.join)(paths.stateDir, "hub"), 448, true);
+    ensureDirectory((0, import_node_path19.join)(paths.stateDir, "hub"), 448, true);
     await backupDatabase2(sourceDatabase, targetDatabase, host);
     copy.record.files.push({
       source: sourceDatabase,
       target: targetDatabase,
       sha256: sha256File2(targetDatabase),
-      bytes: (0, import_node_fs16.statSync)(targetDatabase).size
+      bytes: (0, import_node_fs17.statSync)(targetDatabase).size
     });
   }
-  const sourceCollectorState = (0, import_node_path18.join)(source, "collector", "state.json");
-  if (role !== "hub" && (0, import_node_fs16.existsSync)(sourceCollectorState)) {
+  const sourceCollectorState = (0, import_node_path19.join)(source, "collector", "state.json");
+  if (role !== "hub" && (0, import_node_fs17.existsSync)(sourceCollectorState)) {
     assertPrivateSourceFile(sourceCollectorState, "adopted collector state");
-    ensureDirectory((0, import_node_path18.join)(paths.stateDir, "collector"), 448, true);
+    ensureDirectory((0, import_node_path19.join)(paths.stateDir, "collector"), 448, true);
     const targetCollector = collectorStatePath2(paths);
-    (0, import_node_fs16.copyFileSync)(sourceCollectorState, targetCollector);
-    (0, import_node_fs16.chmodSync)(targetCollector, 384);
+    (0, import_node_fs17.copyFileSync)(sourceCollectorState, targetCollector);
+    (0, import_node_fs17.chmodSync)(targetCollector, 384);
     copy.record.files.push({
       source: sourceCollectorState,
       target: targetCollector,
       sha256: sha256File2(targetCollector),
-      bytes: (0, import_node_fs16.statSync)(targetCollector).size
+      bytes: (0, import_node_fs17.statSync)(targetCollector).size
     });
-    const outbox = (0, import_node_path18.join)(source, "collector", "outbox");
-    if ((0, import_node_fs16.existsSync)(outbox)) copyAdoptedTree(outbox, (0, import_node_path18.join)(paths.stateDir, "collector", "outbox"), copy.record.files);
   }
-  const enrollment = (0, import_node_path18.join)(source, "hub", "enrollment.json");
-  if (role !== "collector" && (0, import_node_fs16.existsSync)(enrollment)) {
+  const enrollment = (0, import_node_path19.join)(source, "hub", "enrollment.json");
+  if (role !== "collector" && (0, import_node_fs17.existsSync)(enrollment)) {
     const target = hubEnrollmentPath(paths);
-    (0, import_node_fs16.copyFileSync)(enrollment, target);
-    (0, import_node_fs16.chmodSync)(target, 384);
-    copy.record.files.push({ source: enrollment, target, sha256: sha256File2(target), bytes: (0, import_node_fs16.statSync)(target).size });
+    (0, import_node_fs17.copyFileSync)(enrollment, target);
+    (0, import_node_fs17.chmodSync)(target, 384);
+    copy.record.files.push({ source: enrollment, target, sha256: sha256File2(target), bytes: (0, import_node_fs17.statSync)(target).size });
   }
 }
 function writeSysusersFiles(paths, accounts, role, power, host) {
@@ -7539,15 +7747,15 @@ function writePowerRule(paths, accounts) {
   writeManagedFile(raplRulePath(paths), renderRaplRule(accounts), 420, true);
 }
 function powerOriginalPath(paths) {
-  return (0, import_node_path18.join)(paths.stateDir, POWER_STATE_FILE_NAME);
+  return (0, import_node_path19.join)(paths.stateDir, POWER_STATE_FILE_NAME);
 }
 function capturePowerOriginals(paths) {
   const files = {};
   for (const domain of packageDomainPaths(paths.powercapRoot)) {
     for (const name of ["energy_uj", "max_energy_range_uj"]) {
-      const path2 = (0, import_node_path18.join)(domain, name);
+      const path2 = (0, import_node_path19.join)(domain, name);
       try {
-        const stat = (0, import_node_fs16.statSync)(path2);
+        const stat = (0, import_node_fs17.statSync)(path2);
         files[path2] = { mode: stat.mode & 511, uid: stat.uid, gid: stat.gid };
       } catch {
       }
@@ -7559,8 +7767,8 @@ function capturePowerOriginals(paths) {
 function applyPowerAccess(paths, accounts, host) {
   for (const domain of packageDomainPaths(paths.powercapRoot)) {
     for (const name of ["energy_uj", "max_energy_range_uj"]) {
-      const path2 = (0, import_node_path18.join)(domain, name);
-      if (!(0, import_node_fs16.existsSync)(path2)) continue;
+      const path2 = (0, import_node_path19.join)(domain, name);
+      if (!(0, import_node_fs17.existsSync)(path2)) continue;
       runRequired(host, "chgrp", [accounts.powerGroup, path2], `power counter group ${path2}`);
       runRequired(host, "chmod", ["0440", path2], `power counter mode ${path2}`);
     }
@@ -7573,9 +7781,9 @@ function resumePowerRule(paths, host) {
 }
 function packageDomainPaths(root) {
   try {
-    return (0, import_node_fs16.readdirSync)(root).filter((entry2) => /^intel-rapl:\d+$/.test(entry2)).map((entry2) => (0, import_node_path18.join)(root, entry2)).filter((path2) => {
+    return (0, import_node_fs17.readdirSync)(root).filter((entry2) => /^intel-rapl:\d+$/.test(entry2)).map((entry2) => (0, import_node_path19.join)(root, entry2)).filter((path2) => {
       try {
-        return /^package/.test((0, import_node_fs16.readFileSync)((0, import_node_path18.join)(path2, "name"), "utf8").trim());
+        return /^package/.test((0, import_node_fs17.readFileSync)((0, import_node_path19.join)(path2, "name"), "utf8").trim());
       } catch {
         return false;
       }
@@ -7595,8 +7803,8 @@ function restorePowerOriginals(paths, host) {
   const files = { ...originals?.files ?? {} };
   for (const domain of packageDomainPaths(paths.powercapRoot)) {
     for (const name of ["energy_uj", "max_energy_range_uj"]) {
-      const path2 = (0, import_node_path18.join)(domain, name);
-      if (!(0, import_node_fs16.existsSync)(path2)) continue;
+      const path2 = (0, import_node_path19.join)(domain, name);
+      if (!(0, import_node_fs17.existsSync)(path2)) continue;
       const original = files[path2];
       if (original) {
         runRequired(host, "chown", [`${original.uid}:${original.gid}`, path2], "restore counter ownership");
@@ -7612,7 +7820,7 @@ function restorePowerOriginals(paths, host) {
     }
   }
   try {
-    (0, import_node_fs16.unlinkSync)(powerOriginalPath(paths));
+    (0, import_node_fs17.unlinkSync)(powerOriginalPath(paths));
   } catch {
   }
   return restored;
@@ -7636,7 +7844,7 @@ function stopUnits(host, units) {
   if (units.some((unit) => systemdActive(host, unit))) throw new SystemError("service-active", "system services did not stop; no files were restored");
 }
 function unitsForCleanup(paths, host) {
-  const legacy = LEGACY_UNIT_NAMES.filter((unit) => (0, import_node_fs16.existsSync)((0, import_node_path18.join)(paths.unitsDir, unit)) || systemdActive(host, unit));
+  const legacy = LEGACY_UNIT_NAMES.filter((unit) => (0, import_node_fs17.existsSync)((0, import_node_path19.join)(paths.unitsDir, unit)) || systemdActive(host, unit));
   return [...Object.values(UNIT_NAMES), ...legacy];
 }
 function startUnits(host, units) {
@@ -7674,7 +7882,7 @@ async function verifySystemHealth(paths, state, host, timeoutMs, components = en
     const report = runRequired(
       host,
       state.nodePath,
-      [(0, import_node_path18.join)(paths.prefix, "current/dist/ops.cjs"), "inspect", "--database", hubDatabasePath(paths), "--json"],
+      [(0, import_node_path19.join)(paths.prefix, "current/dist/ops.cjs"), "inspect", "--database", hubDatabasePath(paths), "--json"],
       "activated database verification",
       { timeoutMs: Math.max(100, deadline - Date.now()) }
     );
@@ -7690,8 +7898,8 @@ async function verifySystemHealth(paths, state, host, timeoutMs, components = en
     let problem = "no sampling marker";
     while (Date.now() < deadline) {
       try {
-        const marker = readJsonObject((0, import_node_path18.join)(paths.stateDir, "collector/health.json"));
-        const lease = readJsonObject((0, import_node_path18.join)(paths.stateDir, "collector/collector-runtime.lock"));
+        const marker = readJsonObject((0, import_node_path19.join)(paths.stateDir, "collector/health.json"));
+        const lease = readJsonObject((0, import_node_path19.join)(paths.stateDir, "collector/collector-runtime.lock"));
         if (marker.pid !== lease.pid || !Number.isSafeInteger(marker.pid)) throw new Error("sampling marker belongs to another process");
         process.kill(Number(marker.pid), 0);
         if (marker.version !== state.currentVersion || !Number.isFinite(marker.sampledAt) || Date.now() - Number(marker.sampledAt) > 15e3) throw new Error("collector version or sampling freshness is wrong");
@@ -7706,12 +7914,12 @@ async function verifySystemHealth(paths, state, host, timeoutMs, components = en
 }
 function chownAccount(paths, owner, group, host) {
   for (const path2 of paths) {
-    if (!(0, import_node_fs16.existsSync)(path2)) continue;
+    if (!(0, import_node_fs17.existsSync)(path2)) continue;
     runRequired(host, "chown", ["-R", `${owner}:${group}`, path2], `ownership ${path2}`);
   }
 }
 function chmodTree(path2, host) {
-  if (!(0, import_node_fs16.existsSync)(path2)) return;
+  if (!(0, import_node_fs17.existsSync)(path2)) return;
   runRequired(host, "chmod", ["-R", "u=rwX,go=rX", path2], `release permissions ${path2}`);
 }
 function pickRollbackBackup(state, previousSchema) {
@@ -7722,9 +7930,12 @@ function pickRollbackBackup(state, previousSchema) {
 async function recoverFailedUpgrade(options) {
   stopUnits(options.host, options.units);
   assertDirectoryStopped(options.paths.stateDir);
-  replaceSymlink((0, import_node_path18.join)(options.paths.prefix, "current"), options.oldCurrent, options.host);
-  if (options.oldPrevious === null) removeSymlink((0, import_node_path18.join)(options.paths.prefix, "previous"));
-  else replaceSymlink((0, import_node_path18.join)(options.paths.prefix, "previous"), options.oldPrevious, options.host);
+  for (const message of undoMachineDataCleanup(systemMachineDataPaths(options.paths), options.machineData?.stagedQueues ?? null)) {
+    console.warn(`rigscope system upgrade recovery: ${message}`);
+  }
+  replaceSymlink((0, import_node_path19.join)(options.paths.prefix, "current"), options.oldCurrent, options.host);
+  if (options.oldPrevious === null) removeSymlink((0, import_node_path19.join)(options.paths.prefix, "previous"));
+  else replaceSymlink((0, import_node_path19.join)(options.paths.prefix, "previous"), options.oldPrevious, options.host);
   const database = hubDatabasePath(options.paths);
   let afterSchema = null;
   try {
@@ -7732,13 +7943,13 @@ async function recoverFailedUpgrade(options) {
   } catch {
     afterSchema = null;
   }
-  if (options.backupPath !== null && (0, import_node_fs16.existsSync)(options.backupPath) && (afterSchema === null || options.beforeSchema === null || afterSchema > options.beforeSchema)) {
-    await backupDatabase2(database, (0, import_node_path18.join)(options.paths.stateDir, "backups", `failed-upgrade-${newestTimestamp()}.sqlite`), options.host);
+  if (options.backupPath !== null && (0, import_node_fs17.existsSync)(options.backupPath) && (afterSchema === null || options.beforeSchema === null || afterSchema > options.beforeSchema || options.machineData?.databaseCleared === true)) {
+    await backupDatabase2(database, (0, import_node_path19.join)(options.paths.stateDir, "backups", `failed-upgrade-${newestTimestamp()}.sqlite`), options.host);
     replaceDatabaseFromBackup(options.backupPath, database, null, options.host);
     runRequired(options.host, "chown", [`${options.state.accounts.hub}:${options.state.accounts.hub}`, database], "restored database ownership");
   }
-  options.state.previousVersion = options.oldPrevious === null ? null : (0, import_node_path18.basename)(options.oldPrevious);
-  options.state.currentVersion = (0, import_node_path18.basename)(options.oldCurrent);
+  options.state.previousVersion = options.oldPrevious === null ? null : (0, import_node_path19.basename)(options.oldPrevious);
+  options.state.currentVersion = (0, import_node_path19.basename)(options.oldCurrent);
   writeSystemState(options.paths, options.state);
   if (options.activeComponents.length > 0) {
     startUnits(options.host, options.units);
@@ -7747,14 +7958,14 @@ async function recoverFailedUpgrade(options) {
 }
 function assertManagedFileOwnership(paths, path2) {
   if (!isDefaultSystemLayout(paths)) return;
-  if (!(0, import_node_fs16.existsSync)(path2)) return;
-  const stat = (0, import_node_fs16.lstatSync)(path2);
+  if (!(0, import_node_fs17.existsSync)(path2)) return;
+  const stat = (0, import_node_fs17.lstatSync)(path2);
   if (stat.isSymbolicLink() || !stat.isFile()) throw new SystemError("unsafe-path", `${path2} must be a regular managed file`);
   if (stat.uid !== 0) throw new SystemError("insecure-ownership", `${path2} must be root-owned before replacement`);
   if ((stat.mode & 18) !== 0) throw new SystemError("insecure-permissions", `${path2} must not be group/world-writable`);
 }
 function writeUnitFile(paths, unit, content, replace) {
-  const path2 = (0, import_node_path18.join)(paths.unitsDir, unit);
+  const path2 = (0, import_node_path19.join)(paths.unitsDir, unit);
   assertManagedFileOwnership(paths, path2);
   writeManagedFile(path2, content, 420, replace);
 }
@@ -7769,19 +7980,19 @@ function ensureComponentSetup(options) {
   ensureDirectory(paths.configDir, 493);
   ensureDirectory(paths.stateDir, 493);
   ensureDirectory(paths.unitsDir, 493);
-  ensureDirectory((0, import_node_path18.join)(paths.stateDir, "hub"), 448, true);
-  ensureDirectory((0, import_node_path18.join)(paths.stateDir, "hub", "run"), 448, true);
-  ensureDirectory((0, import_node_path18.join)(paths.stateDir, "collector"), 448, true);
-  ensureDirectory((0, import_node_path18.join)(paths.stateDir, "backups"), 448, true);
+  ensureDirectory((0, import_node_path19.join)(paths.stateDir, "hub"), 448, true);
+  ensureDirectory((0, import_node_path19.join)(paths.stateDir, "hub", "run"), 448, true);
+  ensureDirectory((0, import_node_path19.join)(paths.stateDir, "collector"), 448, true);
+  ensureDirectory((0, import_node_path19.join)(paths.stateDir, "backups"), 448, true);
   const release = currentReleaseOrThrow(paths);
   void release;
   writeSysusersFiles(paths, accounts, "local", power, host);
   if (component === "hub") {
-    if (!(0, import_node_fs16.existsSync)(hubEnvPath(paths))) {
+    if (!(0, import_node_fs17.existsSync)(hubEnvPath(paths))) {
       const env = hubEnvTemplate(paths);
       writeManagedFile(hubEnvPath(paths), env, 384, false);
     }
-    if (!(0, import_node_fs16.existsSync)((0, import_node_path18.join)(paths.unitsDir, UNIT_NAMES.hub))) {
+    if (!(0, import_node_fs17.existsSync)((0, import_node_path19.join)(paths.unitsDir, UNIT_NAMES.hub))) {
       const env = readHubEnvironment(paths);
       const remote = env.HUB_PUBLIC_ORIGIN !== void 0 && env.HUB_PUBLIC_ORIGIN !== "";
       const unit = renderSystemHubUnit({
@@ -7798,7 +8009,7 @@ function ensureComponentSetup(options) {
 `, false);
     }
   } else {
-    if (!(0, import_node_fs16.existsSync)(collectorEnvPath(paths))) {
+    if (!(0, import_node_fs17.existsSync)(collectorEnvPath(paths))) {
       writeManagedFile(collectorEnvPath(paths), collectorEnvTemplate(), 384, false);
     }
     const unit = renderSystemCollectorUnit({
@@ -7814,17 +8025,17 @@ function ensureComponentSetup(options) {
   const validation = runRequired(
     host,
     "systemd-analyze",
-    ["verify", "--man=no", (0, import_node_path18.join)(paths.unitsDir, unitFor(component))],
+    ["verify", "--man=no", (0, import_node_path19.join)(paths.unitsDir, unitFor(component))],
     "native systemd unit validation"
   );
   if (/path is not absolute|bad unit file|fatal error|unknown (?:key|lvalue)|ignoring/i.test(validation.stderr)) {
     throw new SystemError("invalid-unit", "native systemd validation rejected a generated directive");
   }
-  if (component === "hub") chownAccount([(0, import_node_path18.join)(paths.stateDir, "hub")], accounts.hub, accounts.hub, host);
-  if (component === "collector") chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
+  if (component === "hub") chownAccount([(0, import_node_path19.join)(paths.stateDir, "hub")], accounts.hub, accounts.hub, host);
+  if (component === "collector") chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
 }
 function ensurePowerAccess(paths, accounts, host) {
-  if (!(0, import_node_fs16.existsSync)(powerOriginalPath(paths))) capturePowerOriginals(paths);
+  if (!(0, import_node_fs17.existsSync)(powerOriginalPath(paths))) capturePowerOriginals(paths);
   writePowerRule(paths, accounts);
   resumePowerRule(paths, host);
   applyPowerAccess(paths, accounts, host);
@@ -7842,7 +8053,7 @@ function resetUnfinishedSystemState(options) {
 }
 function installPreset(options, role) {
   if (options.adoptFrom !== void 0) {
-    return componentSet(readAdoptionSetup((0, import_node_path18.resolve)(options.adoptFrom)).components);
+    return componentSet(readAdoptionSetup((0, import_node_path19.resolve)(options.adoptFrom)).components);
   }
   return componentsForRole(role);
 }
@@ -7854,11 +8065,11 @@ function planSystemInstall(options) {
   const power = options.power !== false && preset.collector;
   const initial = options.enable === true ? preset : { hub: false, collector: false };
   const files = [
-    { path: (0, import_node_path18.join)(paths.prefix, "current"), mode: "symlink", purpose: "active root-owned release" },
+    { path: (0, import_node_path19.join)(paths.prefix, "current"), mode: "symlink", purpose: "active root-owned release" },
     { path: hubEnvPath(paths), mode: "0600", purpose: "root-owned hub configuration" },
     { path: collectorEnvPath(paths), mode: "0600", purpose: "root-owned collector configuration" },
     { path: sysusersPath(paths), mode: "0644", purpose: "dedicated nologin accounts" },
-    ...COMPONENTS3.map((component) => ({ path: (0, import_node_path18.join)(paths.unitsDir, unitFor(component)), mode: "0644", purpose: `${component} boot unit` }))
+    ...COMPONENTS3.map((component) => ({ path: (0, import_node_path19.join)(paths.unitsDir, unitFor(component)), mode: "0644", purpose: `${component} boot unit` }))
   ];
   if (power) {
     files.push({ path: raplRulePath(paths), mode: "0644", purpose: "package RAPL read rule" });
@@ -7873,7 +8084,7 @@ function planSystemInstall(options) {
   ];
   const notes = [
     "Nothing is changed without --apply and root.",
-    options.adoptFrom ? `Adopts ${(0, import_node_path18.resolve)(options.adoptFrom)} by copy only; the original user setup is preserved.` : "Existing user services are not modified.",
+    options.adoptFrom ? `Adopts ${(0, import_node_path19.resolve)(options.adoptFrom)} by copy only; the original user setup is preserved.` : "Existing user services are not modified.",
     "One complete package: both runtimes, units and accounts are installed; --role only sets the initial enabled preset.",
     "Hub and collector use separate unprivileged accounts; Node gets no capabilities.",
     ...options.enable && preset.hub ? ["Enabling the hub creates its owner account once and prints the password once."] : [],
@@ -7906,8 +8117,8 @@ async function installSystemUnlocked(options) {
       `existing user service(s) detected (${detail}); stop them and use --adopt-user-state for explicit copy-based adoption`
     );
   }
-  const source = (0, import_node_path18.resolve)(options.source);
-  if (!(0, import_node_fs16.existsSync)(source)) throw new SystemError("missing-source", `release source does not exist: ${source}`);
+  const source = (0, import_node_path19.resolve)(options.source);
+  if (!(0, import_node_fs17.existsSync)(source)) throw new SystemError("missing-source", `release source does not exist: ${source}`);
   const port = options.port ?? 8081;
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new SystemError("invalid-argument", "--port must be 1-65535");
   parseHubConfig(options.origin === void 0 ? { HUB_HOST: "127.0.0.1", HUB_PORT: String(port) } : { HUB_PUBLIC_ORIGIN: options.origin, HUB_SOCKET_PATH: hubSocketPath(paths) });
@@ -7928,14 +8139,14 @@ async function installSystemUnlocked(options) {
   });
   try {
     if (legacy) resetUnfinishedSystemState({ paths, host, now });
-    ensureDirectory((0, import_node_path18.join)(paths.prefix, "releases"), 493);
+    ensureDirectory((0, import_node_path19.join)(paths.prefix, "releases"), 493);
     ensureDirectory(paths.stateDir, 493);
     ensureDirectory(paths.configDir, 493);
     ensureDirectory(paths.unitsDir, 493);
-    ensureDirectory((0, import_node_path18.join)(paths.stateDir, "hub"), 448, true);
-    ensureDirectory((0, import_node_path18.join)(paths.stateDir, "collector"), 448, true);
-    ensureDirectory((0, import_node_path18.join)(paths.stateDir, "backups"), 448, true);
-    ensureDirectory((0, import_node_path18.join)(paths.stateDir, "hub", "run"), 448, true);
+    ensureDirectory((0, import_node_path19.join)(paths.stateDir, "hub"), 448, true);
+    ensureDirectory((0, import_node_path19.join)(paths.stateDir, "collector"), 448, true);
+    ensureDirectory((0, import_node_path19.join)(paths.stateDir, "backups"), 448, true);
+    ensureDirectory((0, import_node_path19.join)(paths.stateDir, "hub", "run"), 448, true);
     const release = commitStagedRelease({ staged, paths, replaceRelease: options.replaceRelease });
     let adoption = null;
     if (options.adoptFrom) {
@@ -7968,13 +8179,13 @@ async function installSystemUnlocked(options) {
 `, true);
     writeUnitFile(paths, UNIT_NAMES.collector, `${collectorUnit}
 `, true);
-    const validation = runRequired(host, "systemd-analyze", ["verify", "--man=no", ...COMPONENTS3.map((component) => (0, import_node_path18.join)(paths.unitsDir, unitFor(component)))], "native systemd unit validation");
+    const validation = runRequired(host, "systemd-analyze", ["verify", "--man=no", ...COMPONENTS3.map((component) => (0, import_node_path19.join)(paths.unitsDir, unitFor(component)))], "native systemd unit validation");
     if (/path is not absolute|bad unit file|fatal error|unknown (?:key|lvalue)|ignoring/i.test(validation.stderr)) {
       throw new SystemError("invalid-unit", "native systemd validation rejected a generated directive");
     }
     if (power) ensurePowerAccess(paths, accounts, host);
-    chownAccount([(0, import_node_path18.join)(paths.stateDir, "hub")], accounts.hub, accounts.hub, host);
-    chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
+    chownAccount([(0, import_node_path19.join)(paths.stateDir, "hub")], accounts.hub, accounts.hub, host);
+    chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], accounts.collector, accounts.collector, host);
     const state = emptyState({ paths, accounts, role, components: { hub: false, collector: false }, nodePath, now });
     state.currentVersion = release.version;
     state.releases[release.version] = {
@@ -7984,7 +8195,7 @@ async function installSystemUnlocked(options) {
     };
     state.adoption = adoption?.record ?? null;
     state.power = power ? { enabled: true, rulePath: raplRulePath(paths), group: accounts.powerGroup } : null;
-    replaceSymlink((0, import_node_path18.join)(paths.prefix, "current"), release.releaseDir, host);
+    replaceSymlink((0, import_node_path19.join)(paths.prefix, "current"), release.releaseDir, host);
     writeSystemState(paths, state);
     const wantsHub = preset.hub && (options.enable === true || options.start === true);
     const wantsCollector = preset.collector && (options.enable === true || options.start === true);
@@ -8010,6 +8221,7 @@ async function installSystemUnlocked(options) {
         await verifySystemHealth(paths, state, host, options.startupTimeoutMs ?? 2e4, started);
       }
     }
+    recordMachineDataTransition(paths.stateDir, release.version, (path2, content) => atomicWrite(path2, content, 384));
     return {
       operation: "install",
       ok: true,
@@ -8038,14 +8250,14 @@ function systemStatus(options = {}) {
   } catch (error2) {
     stateError = error2 instanceof Error ? error2.message : String(error2);
   }
-  const presentUnits = [UNIT_NAMES.hub, UNIT_NAMES.collector].filter((unit) => (0, import_node_fs16.existsSync)((0, import_node_path18.join)(paths.unitsDir, unit)));
+  const presentUnits = [UNIT_NAMES.hub, UNIT_NAMES.collector].filter((unit) => (0, import_node_fs17.existsSync)((0, import_node_path19.join)(paths.unitsDir, unit)));
   const publicRole = presentUnits.length === 2 ? "local" : presentUnits[0] === UNIT_NAMES.hub ? "hub" : presentUnits[0] === UNIT_NAMES.collector ? "collector" : null;
   const role = state?.role ?? publicRole ?? "local";
   const current = currentReleaseDir(paths);
   let publicVersion = null;
   if (current) {
     try {
-      const manifest = JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path18.join)(current, "package.json"), "utf8"));
+      const manifest = JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path19.join)(current, "package.json"), "utf8"));
       if (typeof manifest.version === "string") publicVersion = manifest.version;
     } catch {
     }
@@ -8056,7 +8268,7 @@ function systemStatus(options = {}) {
   const componentReports = {};
   for (const component of COMPONENTS3) {
     const unit = unitFor(component);
-    const present = (0, import_node_fs16.existsSync)((0, import_node_path18.join)(paths.unitsDir, unit));
+    const present = (0, import_node_fs17.existsSync)((0, import_node_path19.join)(paths.unitsDir, unit));
     const active = present && systemdActive(host, unit);
     const unitEnabled2 = present && systemdEnabled(host, unit);
     const enabled = state !== null ? state.components[component].enabled : unitEnabled2;
@@ -8065,7 +8277,7 @@ function systemStatus(options = {}) {
     componentReports[component] = {
       component,
       unit,
-      path: (0, import_node_path18.join)(paths.unitsDir, unit),
+      path: (0, import_node_path19.join)(paths.unitsDir, unit),
       present,
       enabled,
       unitEnabled: unitEnabled2,
@@ -8109,16 +8321,16 @@ function systemStatus(options = {}) {
     })),
     database: {
       path: database,
-      exists: (0, import_node_fs16.existsSync)(database),
+      exists: (0, import_node_fs17.existsSync)(database),
       schema,
-      mode: (0, import_node_fs16.existsSync)(database) ? modeString((0, import_node_fs16.statSync)(database).mode) : null,
+      mode: (0, import_node_fs17.existsSync)(database) ? modeString((0, import_node_fs17.statSync)(database).mode) : null,
       lock
     },
-    socket: { path: hubSocketPath(paths), exists: (0, import_node_fs16.existsSync)(hubSocketPath(paths)) },
+    socket: { path: hubSocketPath(paths), exists: (0, import_node_fs17.existsSync)(hubSocketPath(paths)) },
     config: {
       dir: paths.configDir,
-      hubEnv: { path: hubEnvPath(paths), present: (0, import_node_fs16.existsSync)(hubEnvPath(paths)) },
-      collectorEnv: { path: collectorEnvPath(paths), present: (0, import_node_fs16.existsSync)(collectorEnvPath(paths)) }
+      hubEnv: { path: hubEnvPath(paths), present: (0, import_node_fs17.existsSync)(hubEnvPath(paths)) },
+      collectorEnv: { path: collectorEnvPath(paths), present: (0, import_node_fs17.existsSync)(collectorEnvPath(paths)) }
     },
     adoption: state?.adoption ?? null,
     power,
@@ -8287,7 +8499,7 @@ async function enableSystem(options) {
     ],
     files: [
       { path: component === "hub" ? hubEnvPath(paths) : collectorEnvPath(paths), mode: "0600", purpose: `${component} configuration` },
-      { path: (0, import_node_path18.join)(paths.unitsDir, unitFor(component)), mode: "0644", purpose: `${component} boot unit` }
+      { path: (0, import_node_path19.join)(paths.unitsDir, unitFor(component)), mode: "0644", purpose: `${component} boot unit` }
     ],
     notes: [
       "Enables only the requested component; the other component keeps running.",
@@ -8355,7 +8567,7 @@ function disableSystem(options) {
     accounts: state.accounts,
     commands: [`systemctl stop ${unitFor(component)}`, `systemctl disable ${unitFor(component)}`],
     files: [],
-    notes: ["Settings, credentials, history and outboxes are retained while the component is disabled."]
+    notes: ["Settings, credentials and stored history are retained while the component is disabled; unacknowledged samples held in the collector's RAM delivery queue drain with the process."]
   };
   if (options.apply !== true) return { operation: "disable", ok: true, apply: false, message: "plan only", plan };
   assertApply(host);
@@ -8377,7 +8589,7 @@ function disableSystem(options) {
 function readPrivateToken(path2, read) {
   let stat;
   try {
-    stat = (0, import_node_fs16.lstatSync)(path2);
+    stat = (0, import_node_fs17.lstatSync)(path2);
   } catch (error2) {
     if (error2.code === "ENOENT") {
       throw new SystemError("missing-grant", `grant file does not exist: ${path2}`);
@@ -8388,7 +8600,7 @@ function readPrivateToken(path2, read) {
   if ((stat.mode & 63) !== 0) throw new SystemError("insecure-permissions", `grant file must be private (0600): ${path2}`);
   if (stat.size < 1 || stat.size > 4096) throw new SystemError("invalid-token", `grant file must contain 1-4096 bytes: ${path2}`);
   if (!read) return void 0;
-  const token = (0, import_node_fs16.readFileSync)(path2, "utf8").trim();
+  const token = (0, import_node_fs17.readFileSync)(path2, "utf8").trim();
   if (token === "" || /[\r\n\0]/.test(token) || !/^[\x21-\x7e]{1,256}$/.test(token)) {
     throw new SystemError("invalid-token", "grant file contains an invalid token");
   }
@@ -8400,7 +8612,7 @@ async function connectSystem(options) {
   const state = readSystemState(paths);
   if (state === null || !state.active) throw new SystemError("not-installed", "no active system installation; run install first");
   const destination = connectDestinationUrl(options.url);
-  const tokenFile = (0, import_node_path18.resolve)(options.tokenFile);
+  const tokenFile = (0, import_node_path19.resolve)(options.tokenFile);
   const configured = collectorConfigured(paths);
   if (configured.configured) {
     throw new SystemError(
@@ -8448,12 +8660,12 @@ async function connectSystem(options) {
       `collector enrollment failed: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
   } finally {
-    chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], state.accounts.collector, state.accounts.collector, host);
+    chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], state.accounts.collector, state.accounts.collector, host);
   }
   if (!collectorConfigured(paths).configured) {
     throw new SystemError("enrollment-failed", "the hub accepted enrollment but no destination was saved; check private state");
   }
-  chownAccount([(0, import_node_path18.join)(paths.stateDir, "collector")], state.accounts.collector, state.accounts.collector, host);
+  chownAccount([(0, import_node_path19.join)(paths.stateDir, "collector")], state.accounts.collector, state.accounts.collector, host);
   writeSystemState(paths, state);
   const enabled = state.components.collector.enabled;
   if (enabled || wasActive) {
@@ -8470,13 +8682,16 @@ async function connectSystem(options) {
     state
   };
 }
+function systemMachineDataPaths(paths) {
+  return { database: hubDatabasePath(paths), queueTree: (0, import_node_path19.join)(paths.stateDir, "collector", "outbox") };
+}
 async function upgradeSystemUnlocked(options) {
   const host = options.host ?? createSystemHost();
   const now = options.now ?? Date.now;
   const paths = validateSystemPaths(options.paths);
   if (systemStateIsLegacy(paths)) {
-    const source2 = (0, import_node_path18.resolve)(options.source);
-    if (!(0, import_node_fs16.existsSync)(source2)) throw new SystemError("missing-source", `release source does not exist: ${source2}`);
+    const source2 = (0, import_node_path19.resolve)(options.source);
+    if (!(0, import_node_fs17.existsSync)(source2)) throw new SystemError("missing-source", `release source does not exist: ${source2}`);
     const role = legacySystemRole(paths);
     const preset = componentsForRole(role);
     const enable = options.enable ?? (options.start === true || unitNamesForComponents(preset).some((unit) => systemdEnabled(host, unit)));
@@ -8499,7 +8714,7 @@ async function upgradeSystemUnlocked(options) {
       ],
       files: [
         { path: stateFilePath(paths), mode: "0600", purpose: "canonical replacement state" },
-        { path: (0, import_node_path18.join)(paths.stateDir, "backups"), mode: "0700", purpose: "removed with unfinished history" }
+        { path: (0, import_node_path19.join)(paths.stateDir, "backups"), mode: "0700", purpose: "removed with unfinished history" }
       ],
       notes: [
         "An unfinished installation is reset, not migrated; its history and credentials are removed.",
@@ -8532,6 +8747,7 @@ async function upgradeSystemUnlocked(options) {
   if (state === null || !state.active) throw new SystemError("not-installed", "no active system installation; run install first");
   const activeComponents = COMPONENTS3.filter((component) => systemdActive(host, unitFor(component)));
   const activeUnits = activeComponents.map(unitFor);
+  const transitionPending = readMachineDataTransition(paths.stateDir) === null;
   const plan = {
     operation: "upgrade",
     apply: options.apply === true,
@@ -8539,19 +8755,34 @@ async function upgradeSystemUnlocked(options) {
     components: { hub: state.components.hub.enabled, collector: state.components.collector.enabled },
     paths,
     accounts: state.accounts,
-    commands: ["stage new release", ...activeUnits.map((unit) => `systemctl stop ${unit}`), "backup database", "switch current", ...activeUnits.map((unit) => `systemctl start ${unit}`)],
-    files: [{ path: (0, import_node_path18.join)(paths.stateDir, "backups"), mode: "0700", purpose: "pre-upgrade database backup" }],
+    commands: [
+      "stage new release",
+      ...activeUnits.map((unit) => `systemctl stop ${unit}`),
+      "backup database",
+      ...transitionPending ? ["discard legacy machine data and collector queues once (irreversible after success)"] : [],
+      "switch current",
+      ...activeUnits.map((unit) => `systemctl start ${unit}`)
+    ],
+    files: [
+      { path: (0, import_node_path19.join)(paths.stateDir, "backups"), mode: "0700", purpose: "pre-upgrade database backup" },
+      ...transitionPending ? [{ path: (0, import_node_path19.join)(paths.stateDir, "machine-data-transition.json"), mode: "0600", purpose: "written once after the transition completes" }] : []
+    ],
     notes: [
       "Staging happens before any service is stopped.",
       "The exact active component set is restored; --start does not start a component that was stopped.",
-      "A failed post-upgrade start restores the previous release and matching database backup."
+      "A failed post-upgrade start restores the previous release and matching database backup.",
+      ...transitionPending ? [
+        "This upgrade completes the one-time RAM-first machine-data transition: telemetry rows, summaries, receipts, gaps, latest snapshots, inventory and machine-derived alert history are discarded, plus the pre-RAM-first durable collector queue. The transition's database copy restores the rows and the staged queue is renamed back if activation fails.",
+        `The transition always keeps ${machineDataKeptNote()}.`,
+        "Later upgrades keep the marker and preserve durable history and queues."
+      ] : ["The one-time machine-data transition already completed; durable history and collector queues are preserved."]
     ]
   };
   if (options.apply !== true) return { operation: "upgrade", ok: true, apply: false, message: "plan only", plan };
   assertApply(host);
   assertManagedPathSafety(paths, isDefaultSystemLayout(paths));
-  const source = (0, import_node_path18.resolve)(options.source);
-  if (!(0, import_node_fs16.existsSync)(source)) throw new SystemError("missing-source", `release source does not exist: ${source}`);
+  const source = (0, import_node_path19.resolve)(options.source);
+  if (!(0, import_node_fs17.existsSync)(source)) throw new SystemError("missing-source", `release source does not exist: ${source}`);
   const staged = prepareStagedRelease({
     source,
     paths,
@@ -8570,21 +8801,22 @@ async function upgradeSystemUnlocked(options) {
     let backupPath = null;
     let beforeSchema = null;
     let release = null;
+    let machineData = null;
     try {
       stopUnits(host, activeUnits);
       assertDirectoryStopped(paths.stateDir);
       const lock = systemLockState(paths);
       if (lock.live) throw new SystemError("duplicate-runtime", `hub did not stop cleanly; lock remains at ${lock.path}`);
       const database = hubDatabasePath(paths);
-      if ((0, import_node_fs16.existsSync)(database)) {
-        ensureDirectory((0, import_node_path18.join)(paths.stateDir, "backups"), 448, true);
+      if ((0, import_node_fs17.existsSync)(database)) {
+        ensureDirectory((0, import_node_path19.join)(paths.stateDir, "backups"), 448, true);
         beforeSchema = databaseSchema(database);
-        backupPath = (0, import_node_path18.join)(paths.stateDir, "backups", `pre-upgrade-${staged.version}-${newestTimestamp()}.sqlite`);
+        backupPath = (0, import_node_path19.join)(paths.stateDir, "backups", `pre-upgrade-${staged.version}-${newestTimestamp()}.sqlite`);
         await backupDatabase2(database, backupPath, host);
       }
       release = commitStagedRelease({ staged, paths, replaceRelease: options.replaceRelease });
-      replaceSymlink((0, import_node_path18.join)(paths.prefix, "previous"), oldCurrent, host);
-      replaceSymlink((0, import_node_path18.join)(paths.prefix, "current"), release.releaseDir, host);
+      replaceSymlink((0, import_node_path19.join)(paths.prefix, "previous"), oldCurrent, host);
+      replaceSymlink((0, import_node_path19.join)(paths.prefix, "current"), release.releaseDir, host);
       state.previousVersion = state.currentVersion;
       state.currentVersion = release.version;
       state.releases[release.version] = {
@@ -8593,7 +8825,7 @@ async function upgradeSystemUnlocked(options) {
         installedAt: new Date(now()).toISOString()
       };
       if (backupPath !== null) {
-        state.backups[(0, import_node_path18.basename)(backupPath)] = {
+        state.backups[(0, import_node_path19.basename)(backupPath)] = {
           path: backupPath,
           schemaVersion: beforeSchema,
           fromSchema: beforeSchema,
@@ -8604,6 +8836,7 @@ async function upgradeSystemUnlocked(options) {
         };
       }
       writeSystemState(paths, state);
+      machineData = performMachineDataCleanup(paths.stateDir, systemMachineDataPaths(paths), now);
       if (activeComponents.length > 0) {
         startUnits(host, activeUnits);
         await verifySystemHealth(paths, state, host, options.startupTimeoutMs ?? 2e4, activeComponents);
@@ -8616,6 +8849,7 @@ async function upgradeSystemUnlocked(options) {
         oldPrevious,
         beforeSchema,
         backupPath,
+        machineData,
         host,
         activeComponents,
         units: activeUnits
@@ -8623,6 +8857,10 @@ async function upgradeSystemUnlocked(options) {
       throw error2;
     }
     const upgraded = release;
+    if (machineData !== null) {
+      completeMachineDataCleanup(paths.stateDir, machineData, upgraded.version, (path2, content) => atomicWrite(path2, content, 384));
+    }
+    const machineHistory = machineData?.report;
     return {
       operation: "upgrade",
       ok: true,
@@ -8632,6 +8870,7 @@ async function upgradeSystemUnlocked(options) {
       current: upgraded.releaseDir,
       previous: oldCurrent,
       backupPath,
+      ...machineHistory ? { machineHistory } : {},
       state
     };
   } finally {
@@ -8639,7 +8878,7 @@ async function upgradeSystemUnlocked(options) {
   }
 }
 function systemOperationLockPath(paths) {
-  return (0, import_node_path18.join)(paths.prefix, "run", "operation.lock");
+  return (0, import_node_path19.join)(paths.prefix, "run", "operation.lock");
 }
 async function withSystemOperation(options, operation) {
   if (!options.apply) return operation();
@@ -8647,7 +8886,7 @@ async function withSystemOperation(options, operation) {
   assertApply(host);
   const paths = validateSystemPaths(options.paths);
   ensureDirectory(paths.prefix, 493);
-  ensureDirectory((0, import_node_path18.join)(paths.prefix, "run"), 448, true);
+  ensureDirectory((0, import_node_path19.join)(paths.prefix, "run"), 448, true);
   const release = acquireProcessLease(systemOperationLockPath(paths));
   try {
     return await operation();
@@ -8699,24 +8938,24 @@ async function rollbackSystemUnlocked(options = {}) {
   try {
     stopUnits(host, units);
     assertDirectoryStopped(paths.stateDir);
-    if (systemLockState(paths).live || lockIsLive((0, import_node_path18.join)(paths.stateDir, "collector/collector-runtime.lock")).live) {
+    if (systemLockState(paths).live || lockIsLive((0, import_node_path19.join)(paths.stateDir, "collector/collector-runtime.lock")).live) {
       throw new SystemError("runtime-active", "runtime lease remains after stop; rollback refused");
     }
     const database = hubDatabasePath(paths);
-    const currentSchema = (0, import_node_fs16.existsSync)(database) ? databaseSchema(database) : null;
+    const currentSchema = (0, import_node_fs17.existsSync)(database) ? databaseSchema(database) : null;
     let backupToRestore = null;
     if (currentSchema !== null && (previousSchema === null || currentSchema > previousSchema)) {
       backupToRestore = pickRollbackBackup(state, previousSchema);
-      if (backupToRestore === null || !(0, import_node_fs16.existsSync)(backupToRestore.path)) {
+      if (backupToRestore === null || !(0, import_node_fs17.existsSync)(backupToRestore.path)) {
         throw new SystemError(
           "incompatible-schema",
           `current database schema ${currentSchema} is newer than release ${previousVersion}; no matching pre-upgrade backup is recorded`
         );
       }
     }
-    if ((0, import_node_fs16.existsSync)(database)) {
-      ensureDirectory((0, import_node_path18.join)(paths.stateDir, "backups"), 448, true);
-      safetyBackup = (0, import_node_path18.join)(paths.stateDir, "backups", `pre-rollback-${newestTimestamp()}.sqlite`);
+    if ((0, import_node_fs17.existsSync)(database)) {
+      ensureDirectory((0, import_node_path19.join)(paths.stateDir, "backups"), 448, true);
+      safetyBackup = (0, import_node_path19.join)(paths.stateDir, "backups", `pre-rollback-${newestTimestamp()}.sqlite`);
       await backupDatabase2(database, safetyBackup, host);
     }
     if (backupToRestore !== null) {
@@ -8724,8 +8963,8 @@ async function rollbackSystemUnlocked(options = {}) {
       restoredDatabase = true;
       runRequired(host, "chown", [`${state.accounts.hub}:${state.accounts.hub}`, database], "restored database ownership");
     }
-    replaceSymlink((0, import_node_path18.join)(paths.prefix, "previous"), oldCurrent, host);
-    replaceSymlink((0, import_node_path18.join)(paths.prefix, "current"), previous, host);
+    replaceSymlink((0, import_node_path19.join)(paths.prefix, "previous"), oldCurrent, host);
+    replaceSymlink((0, import_node_path19.join)(paths.prefix, "current"), previous, host);
     state.previousVersion = state.currentVersion;
     state.currentVersion = previousVersion;
     state.updatedAt = new Date(now()).toISOString();
@@ -8747,10 +8986,10 @@ async function rollbackSystemUnlocked(options = {}) {
     };
   } catch (error2) {
     stopUnits(host, units);
-    replaceSymlink((0, import_node_path18.join)(paths.prefix, "current"), oldCurrent, host);
-    replaceSymlink((0, import_node_path18.join)(paths.prefix, "previous"), previous, host);
+    replaceSymlink((0, import_node_path19.join)(paths.prefix, "current"), oldCurrent, host);
+    replaceSymlink((0, import_node_path19.join)(paths.prefix, "previous"), previous, host);
     if (restoredDatabase && safetyBackup) {
-      const failed = (0, import_node_path18.join)(paths.stateDir, "backups", `failed-rollback-${newestTimestamp()}.sqlite`);
+      const failed = (0, import_node_path19.join)(paths.stateDir, "backups", `failed-rollback-${newestTimestamp()}.sqlite`);
       await backupDatabase2(hubDatabasePath(paths), failed, host);
       replaceDatabaseFromBackup(safetyBackup, hubDatabasePath(paths), null, host);
       runRequired(host, "chown", [`${state.accounts.hub}:${state.accounts.hub}`, hubDatabasePath(paths)], "restored database ownership");
@@ -8807,31 +9046,31 @@ function uninstallSystem(options = {}) {
   assertDirectoryStopped(paths.stateDir);
   for (const unit of units) runMaybe(host, "systemctl", ["disable", unit]);
   for (const unit of units) {
-    const path2 = (0, import_node_path18.join)(paths.unitsDir, unit);
+    const path2 = (0, import_node_path19.join)(paths.unitsDir, unit);
     assertManagedFileOwnership(paths, path2);
     try {
-      (0, import_node_fs16.unlinkSync)(path2);
+      (0, import_node_fs17.unlinkSync)(path2);
     } catch {
     }
   }
   runMaybe(host, "systemctl", ["daemon-reload"]);
-  const hadPowerAccess = state?.power?.enabled === true || (0, import_node_fs16.existsSync)(raplRulePath(paths)) || (0, import_node_fs16.existsSync)(powerOriginalPath(paths));
+  const hadPowerAccess = state?.power?.enabled === true || (0, import_node_fs17.existsSync)(raplRulePath(paths)) || (0, import_node_fs17.existsSync)(powerOriginalPath(paths));
   if (hadPowerAccess) {
     try {
-      (0, import_node_fs16.unlinkSync)(raplRulePath(paths));
+      (0, import_node_fs17.unlinkSync)(raplRulePath(paths));
     } catch {
     }
     try {
-      (0, import_node_fs16.unlinkSync)(powerSysusersPath(paths));
+      (0, import_node_fs17.unlinkSync)(powerSysusersPath(paths));
     } catch {
     }
     restorePowerOriginals(paths, host);
     resumePowerRule(paths, host);
   }
-  removeSymlink((0, import_node_path18.join)(paths.prefix, "current"));
-  removeSymlink((0, import_node_path18.join)(paths.prefix, "previous"));
-  (0, import_node_fs16.rmSync)((0, import_node_path18.join)(paths.prefix, "releases"), { recursive: true, force: true });
-  if (options.preserveNode !== true) (0, import_node_fs16.rmSync)((0, import_node_path18.join)(paths.prefix, "node"), { recursive: true, force: true });
+  removeSymlink((0, import_node_path19.join)(paths.prefix, "current"));
+  removeSymlink((0, import_node_path19.join)(paths.prefix, "previous"));
+  (0, import_node_fs17.rmSync)((0, import_node_path19.join)(paths.prefix, "releases"), { recursive: true, force: true });
+  if (options.preserveNode !== true) (0, import_node_fs17.rmSync)((0, import_node_path19.join)(paths.prefix, "node"), { recursive: true, force: true });
   if (state !== null) {
     state.active = false;
     state.power = null;
@@ -8844,8 +9083,8 @@ function uninstallSystem(options = {}) {
     for (const group of [accounts.powerGroup, accounts.hub, accounts.collector]) runMaybe(host, "groupdel", [group]);
   }
   if (options.purgeData === true) {
-    (0, import_node_fs16.rmSync)(paths.stateDir, { recursive: true, force: true });
-    (0, import_node_fs16.rmSync)(paths.configDir, { recursive: true, force: true });
+    (0, import_node_fs17.rmSync)(paths.stateDir, { recursive: true, force: true });
+    (0, import_node_fs17.rmSync)(paths.configDir, { recursive: true, force: true });
   }
   return {
     operation: "uninstall",
@@ -8895,7 +9134,7 @@ function grantPower(options = {}) {
   writeManagedFile(powerSysusersPath(paths), renderPowerSysusers(paths, accounts), 420, true);
   runRequired(host, "systemd-sysusers", [], "power group creation");
   assertSystemAccounts(host, accounts, true, ["collector"]);
-  if (!(0, import_node_fs16.existsSync)(powerOriginalPath(paths))) capturePowerOriginals(paths);
+  if (!(0, import_node_fs17.existsSync)(powerOriginalPath(paths))) capturePowerOriginals(paths);
   writePowerRule(paths, accounts);
   resumePowerRule(paths, host);
   applyPowerAccess(paths, accounts, host);
@@ -8924,11 +9163,11 @@ function revokePower(options = {}) {
   if (options.apply !== true) return { operation: "power-revoke", ok: true, apply: false, message: "plan only", plan };
   assertApply(host);
   try {
-    (0, import_node_fs16.unlinkSync)(raplRulePath(paths));
+    (0, import_node_fs17.unlinkSync)(raplRulePath(paths));
   } catch {
   }
   try {
-    (0, import_node_fs16.unlinkSync)(powerSysusersPath(paths));
+    (0, import_node_fs17.unlinkSync)(powerSysusersPath(paths));
   } catch {
   }
   restorePowerOriginals(paths, host);
@@ -9144,6 +9383,12 @@ function printMutationReport(report) {
     console.log("then run `rigscope system connect https://<hub> --token-file <file> --apply`.");
   }
 }
+function printMachineDataOutcome(machineHistory) {
+  if (machineHistory === void 0) return;
+  const described = describeMachineDataReport(machineHistory);
+  console.log(described.summary);
+  if (described.warning) console.log(`Warning: ${described.warning}`);
+}
 async function runSystemCommand(argv) {
   const parsed = parseSystemArgs(argv);
   if (parsed.command === "help") {
@@ -9215,7 +9460,7 @@ ${humanPlan(report.plan)}`);
     if (parsed.command === "logs") {
       const selected = validateSystemPaths(paths);
       const component = componentFrom(parsed, false);
-      const units = (component ? [unitFor(component)] : [UNIT_NAMES.hub, UNIT_NAMES.collector]).filter((unit) => (0, import_node_fs16.existsSync)((0, import_node_path18.join)(selected.unitsDir, unit)));
+      const units = (component ? [unitFor(component)] : [UNIT_NAMES.hub, UNIT_NAMES.collector]).filter((unit) => (0, import_node_fs17.existsSync)((0, import_node_path19.join)(selected.unitsDir, unit)));
       if (units.length === 0) throw new SystemError("not-installed", component ? `${component} logs are unavailable; its unit is not installed` : "no system services installed");
       const result = (0, import_node_child_process5.spawnSync)("journalctl", [...units.flatMap((unit) => ["--unit", unit]), "--lines=100", "--no-pager", ...boolValue(values, "follow") ? ["--follow"] : []], { stdio: "inherit" });
       if (result.error) throw result.error;
@@ -9291,6 +9536,7 @@ ${humanPlan(report.plan)}`);
       else {
         printMutationReport(report);
         console.log(`Backup: ${report.backupPath ?? "none"}`);
+        printMachineDataOutcome(report.machineHistory);
       }
       return 0;
     }
@@ -9396,7 +9642,7 @@ if (isMainModule()) {
 }
 
 // src/cli/selection.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 function selectInstallation(options) {
   if (options.scope !== void 0 && options.scope !== "user" && options.scope !== "system") {
     throw new Error("--scope must be user or system.");
@@ -9412,16 +9658,16 @@ function selectInstallation(options) {
   return options.systemPresent ? "system" : "user";
 }
 function systemInstallationPresent() {
-  return (0, import_node_fs17.existsSync)("/opt/rigscope/current") || (0, import_node_fs17.existsSync)("/etc/systemd/system/rigscope-hub.service") || (0, import_node_fs17.existsSync)("/etc/systemd/system/rigscope-collector.service");
+  return (0, import_node_fs18.existsSync)("/opt/rigscope/current") || (0, import_node_fs18.existsSync)("/etc/systemd/system/rigscope-hub.service") || (0, import_node_fs18.existsSync)("/etc/systemd/system/rigscope-collector.service");
 }
 
 // src/cli/access.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path19 = require("node:path");
-var import_node_crypto13 = require("node:crypto");
+var import_node_fs19 = require("node:fs");
+var import_node_path20 = require("node:path");
+var import_node_crypto14 = require("node:crypto");
 
 // collector/destinations/outbox.ts
-var import_node_crypto12 = require("node:crypto");
+var import_node_crypto13 = require("node:crypto");
 var path = __toESM(require("node:path"));
 var import_node_sqlite5 = require("node:sqlite");
 var DEFAULT_OUTBOX_LIMITS = {
@@ -9433,7 +9679,7 @@ var DEFAULT_OUTBOX_LIMITS = {
 var DEFAULT_OUTBOX_DISK_BYTES = 80 * 1024 * 1024;
 var WRITE_HEADROOM_BYTES = 16 * 1024;
 function outboxDirFor(stateDir, url) {
-  const digest = (0, import_node_crypto12.createHash)("sha256").update(url, "utf8").digest("hex").slice(0, 16);
+  const digest = (0, import_node_crypto13.createHash)("sha256").update(url, "utf8").digest("hex").slice(0, 16);
   return path.join(stateDir, "outbox", digest);
 }
 
@@ -9443,7 +9689,7 @@ function endpointFor(config) {
 }
 function readCollectorState(dir) {
   try {
-    return JSON.parse(readPrivate((0, import_node_path19.join)(dir, "collector", "state.json")));
+    return JSON.parse(readPrivate((0, import_node_path20.join)(dir, "collector", "state.json")));
   } catch (error2) {
     if (error2.code === "ENOENT") return null;
     throw error2;
@@ -9468,7 +9714,7 @@ function planAccessChange(dir, options) {
     delete next.socket;
   } else if (options.origin) {
     next.origin = options.origin;
-    next.socket = options.socket ?? (0, import_node_path19.join)(dir, "run", "hub.sock");
+    next.socket = options.socket ?? (0, import_node_path20.join)(dir, "run", "hub.sock");
   }
   parseHubConfig(hubEnvironment(dir, next));
   const oldEndpoint = endpointFor(previous);
@@ -9484,8 +9730,8 @@ function planAccessChange(dir, options) {
     collectorChanged,
     oldEndpoint,
     newEndpoint,
-    oldQueue: collectorChanged ? outboxDirFor((0, import_node_path19.join)(dir, "collector"), oldEndpoint) : null,
-    newQueue: collectorChanged ? outboxDirFor((0, import_node_path19.join)(dir, "collector"), newEndpoint) : null,
+    oldQueue: collectorChanged ? outboxDirFor((0, import_node_path20.join)(dir, "collector"), oldEndpoint) : null,
+    newQueue: collectorChanged ? outboxDirFor((0, import_node_path20.join)(dir, "collector"), newEndpoint) : null,
     state,
     self
   };
@@ -9493,22 +9739,22 @@ function planAccessChange(dir, options) {
 function configureAccess(dir, options) {
   const plan = planAccessChange(dir, options);
   if (!plan.changed) return { changed: false, backup: null, url: plan.url };
-  const configPath = (0, import_node_path19.join)(dir, "config.json");
-  const statePath = (0, import_node_path19.join)(dir, "collector", "state.json");
+  const configPath = (0, import_node_path20.join)(dir, "config.json");
+  const statePath = (0, import_node_path20.join)(dir, "collector", "state.json");
   const beforeConfig = readPrivate(configPath);
   const beforeState = plan.state === null ? null : readPrivate(statePath);
-  if (plan.collectorChanged && plan.oldQueue && plan.newQueue && plan.oldQueue !== plan.newQueue && (0, import_node_fs18.existsSync)(plan.newQueue)) {
+  if (plan.collectorChanged && plan.oldQueue && plan.newQueue && plan.oldQueue !== plan.newQueue && (0, import_node_fs19.existsSync)(plan.newQueue)) {
     throw new Error("The destination already has an outbox. Preserve or replay it before changing access.");
   }
-  if (plan.oldQueue && (0, import_node_fs18.existsSync)(plan.oldQueue)) {
-    const stat = (0, import_node_fs18.lstatSync)(plan.oldQueue);
+  if (plan.oldQueue && (0, import_node_fs19.existsSync)(plan.oldQueue)) {
+    const stat = (0, import_node_fs19.lstatSync)(plan.oldQueue);
     if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Collector outbox must be a real directory.");
   }
-  const backup3 = (0, import_node_path19.join)(dir, "backups", `access-${(0, import_node_crypto13.randomUUID)()}`);
+  const backup3 = (0, import_node_path20.join)(dir, "backups", `access-${(0, import_node_crypto14.randomUUID)()}`);
   privateDirectory(backup3);
-  writePrivateFile((0, import_node_path19.join)(backup3, "config.json"), beforeConfig);
-  if (beforeState !== null) writePrivateFile((0, import_node_path19.join)(backup3, "collector-state.json"), beforeState);
-  writePrivateFile((0, import_node_path19.join)(backup3, "change.json"), JSON.stringify({
+  writePrivateFile((0, import_node_path20.join)(backup3, "config.json"), beforeConfig);
+  if (beforeState !== null) writePrivateFile((0, import_node_path20.join)(backup3, "collector-state.json"), beforeState);
+  writePrivateFile((0, import_node_path20.join)(backup3, "change.json"), JSON.stringify({
     oldEndpoint: plan.collectorChanged ? plan.oldEndpoint : null,
     newEndpoint: plan.collectorChanged ? plan.newEndpoint : null,
     oldQueue: plan.oldQueue,
@@ -9516,8 +9762,8 @@ function configureAccess(dir, options) {
   }));
   let movedQueue = false;
   try {
-    if (plan.oldQueue && plan.newQueue && plan.oldQueue !== plan.newQueue && (0, import_node_fs18.existsSync)(plan.oldQueue)) {
-      (0, import_node_fs18.renameSync)(plan.oldQueue, plan.newQueue);
+    if (plan.oldQueue && plan.newQueue && plan.oldQueue !== plan.newQueue && (0, import_node_fs19.existsSync)(plan.oldQueue)) {
+      (0, import_node_fs19.renameSync)(plan.oldQueue, plan.newQueue);
       movedQueue = true;
     }
     if (plan.collectorChanged && plan.state && plan.self) {
@@ -9533,7 +9779,7 @@ function configureAccess(dir, options) {
     try {
       writePrivateFile(configPath, beforeConfig);
       if (beforeState !== null) writePrivateFile(statePath, beforeState);
-      if (movedQueue) (0, import_node_fs18.renameSync)(plan.newQueue, plan.oldQueue);
+      if (movedQueue) (0, import_node_fs19.renameSync)(plan.newQueue, plan.oldQueue);
     } catch {
       throw new Error(`Access change could not be recovered. Keep the service stopped and restore configuration from ${backup3}.`);
     }
@@ -9543,7 +9789,7 @@ function configureAccess(dir, options) {
 }
 
 // src/cli/main.ts
-var ROOT = (0, import_node_path20.resolve)(__dirname, "..");
+var ROOT = (0, import_node_path21.resolve)(__dirname, "..");
 var HELP2 = `Rigscope \u2014 your machines, in view
 
 Usage: rigscope <command> [options]
@@ -9664,7 +9910,7 @@ async function readPassword() {
   }
 }
 function passwordFromFile(path2) {
-  const raw = readPrivate((0, import_node_path20.resolve)(path2));
+  const raw = readPrivate((0, import_node_path21.resolve)(path2));
   return raw.replace(/\r?\n$/, "");
 }
 function healthDeadline(value) {
@@ -9705,7 +9951,12 @@ function announce(setup, dir) {
 Password: ${setup.password}`);
     printWarning("Save this password; it is shown once.");
   }
-  console.log(`Configuration: ${(0, import_node_path20.join)(dir, "config.json")}`);
+  console.log(`Configuration: ${(0, import_node_path21.join)(dir, "config.json")}`);
+}
+function printMachineDataOutcome2(machineHistory) {
+  const described = describeMachineDataReport(machineHistory);
+  console.log(described.summary);
+  if (described.warning !== null) printWarning(described.warning);
 }
 async function main() {
   const argv = process.argv.slice(2);
@@ -9745,7 +9996,7 @@ async function main() {
     return 0;
   }
   if (values.version) {
-    console.log(JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path20.join)(ROOT, "package.json"), "utf8")).version);
+    console.log(JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path21.join)(ROOT, "package.json"), "utf8")).version);
     return 0;
   }
   if (process.platform !== "linux") throw new Error("Rigscope currently supports Linux.");
@@ -9777,13 +10028,13 @@ async function main() {
     if (value !== void 0 && key !== "state-dir" && key !== "scope" && !(permitted[command] ?? []).includes(key)) throw new Error(`--${key} is not available for ${command}.`);
   }
   if (values.origin?.endsWith("/")) values.origin = values.origin.slice(0, -1);
-  const managedState = (0, import_node_path20.basename)(ROOT) === "rigscope" && (0, import_node_path20.basename)((0, import_node_path20.dirname)(ROOT)) === "node_modules" && (0, import_node_path20.basename)((0, import_node_path20.resolve)(ROOT, "../..")) === "runtime" ? (0, import_node_path20.resolve)(ROOT, "../../..") : void 0;
+  const managedState = (0, import_node_path21.basename)(ROOT) === "rigscope" && (0, import_node_path21.basename)((0, import_node_path21.dirname)(ROOT)) === "node_modules" && (0, import_node_path21.basename)((0, import_node_path21.resolve)(ROOT, "../..")) === "runtime" ? (0, import_node_path21.resolve)(ROOT, "../../..") : void 0;
   const dir = stateDirectory(values["state-dir"] ?? (command === "try" ? `${stateDirectory()}-trial` : process.env.RIGSCOPE_STATE_DIR ?? managedState));
   const explicitState = Boolean(values["state-dir"] || process.env.RIGSCOPE_STATE_DIR || managedState || command === "try" || command === "run");
   const scope = selectInstallation({
     scope: values.scope ?? (explicitState ? "user" : void 0),
     explicitState: Boolean(values["state-dir"]),
-    userPresent: (0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "config.json")),
+    userPresent: (0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "config.json")),
     systemPresent: systemInstallationPresent()
   });
   if (scope === "system") {
@@ -9793,7 +10044,7 @@ async function main() {
     throw new Error(`System installation selected. Use rigscope system ${command} (mutations require sudo and --apply), or --scope user for a user installation.`);
   }
   if (command === "config") {
-    console.log((0, import_node_path20.join)(dir, "config.json"));
+    console.log((0, import_node_path21.join)(dir, "config.json"));
     return 0;
   }
   if (command === "upgrade" && installationNeedsReset(dir)) {
@@ -9824,7 +10075,7 @@ async function main() {
     if (values.enable && values["no-enable"]) throw new Error("Choose --enable or --no-enable.");
     if (values.boot && values["no-enable"]) throw new Error("--boot requires startup to be enabled.");
   }
-  const grant = command === "connect" ? values["token-file"] ? readPrivate((0, import_node_path20.resolve)(values["token-file"])).trim() : await readGrant() : void 0;
+  const grant = command === "connect" ? values["token-file"] ? readPrivate((0, import_node_path21.resolve)(values["token-file"])).trim() : await readGrant() : void 0;
   let recoveryPassword;
   if (command === "recover-password") {
     const saved = readSetup(dir);
@@ -9862,7 +10113,7 @@ async function main() {
     }
     if (command === "try") {
       if (values.role && values.role !== "local") throw new Error("Use install for a hub or collector.");
-      if ((0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime"))) throw new Error("This is an installed runtime. Use rigscope start, or choose a separate --state-dir for a trial.");
+      if ((0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime"))) throw new Error("This is an installed runtime. Use rigscope start, or choose a separate --state-dir for a trial.");
       const setup = initialize(dir, { role: "local", port: values.port ?? "8082" });
       console.log("Trial: foreground hub + collector. Ctrl+C stops both.");
       announce(setup, dir);
@@ -9878,20 +10129,20 @@ async function main() {
       const releases = [];
       try {
         releases.push(acquireProcessLease(componentLeasePath(dir, "collector")));
-        releases.push(acquireProcessLease((0, import_node_path20.join)(dir, "collector", "collector-runtime.lock")));
-        await enrollCollector((0, import_node_path20.join)(dir, "collector", "state.json"), url, token, DEFAULT_SHARING, values.replace);
+        releases.push(acquireProcessLease((0, import_node_path21.join)(dir, "collector", "collector-runtime.lock")));
+        await enrollCollector((0, import_node_path21.join)(dir, "collector", "state.json"), url, token, DEFAULT_SHARING, values.replace);
       } finally {
         for (const release of releases.reverse()) release();
       }
       configureComponent(dir, "collector", { enabled: true, pairColocated: false });
-      if ((0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime"))) {
+      if ((0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime"))) {
         writeService(dir, "collector");
         systemctl(dir, "enable", false, "collector");
       }
-      if (!values["no-start"] && !values["no-restart"] && (0, import_node_fs19.existsSync)(unitPath(dir, "collector"))) {
+      if (!values["no-start"] && !values["no-restart"] && (0, import_node_fs20.existsSync)(unitPath(dir, "collector"))) {
         console.log(`Hub connected. Background service ${await startInstallation(dir, "collector")}.`);
       } else {
-        console.log(`Hub connected. Run rigscope ${(0, import_node_fs19.existsSync)(unitPath(dir, "collector")) ? "start collector" : `install --state-dir ${shellQuote2(dir)}`}.`);
+        console.log(`Hub connected. Run rigscope ${(0, import_node_fs20.existsSync)(unitPath(dir, "collector")) ? "start collector" : `install --state-dir ${shellQuote2(dir)}`}.`);
       }
       return 0;
     }
@@ -9900,10 +10151,10 @@ async function main() {
       const existing = readSetup(dir);
       if (!existing) throw new Error("No saved installation. Run rigscope install first.");
       if (command === "enable") {
-        if (!(0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime"))) throw new Error("Install the runtime first: rigscope install --no-start.");
+        if (!(0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime"))) throw new Error("Install the runtime first: rigscope install --no-start.");
         if (target === "hub" && (existing.users.length > 0 || existing.origin) && (values.origin !== void 0 || values.socket !== void 0 || values.port !== void 0)) {
           const nextOrigin = values.origin !== void 0 ? values.origin : existing.origin;
-          const nextSocket = values.origin !== void 0 ? values.socket ?? (0, import_node_path20.join)(dir, "run", "hub.sock") : values.socket ?? existing.socket;
+          const nextSocket = values.origin !== void 0 ? values.socket ?? (0, import_node_path21.join)(dir, "run", "hub.sock") : values.socket ?? existing.socket;
           const nextPort = values.port !== void 0 ? Number(values.port) : existing.port;
           if (nextOrigin !== existing.origin || nextSocket !== existing.socket || nextPort !== existing.port) {
             throw new Error("Change hub access with rigscope configure.");
@@ -9941,7 +10192,7 @@ Save this password; it is shown once.`);
       if (values.boot && values["no-enable"]) throw new Error("--boot requires startup to be enabled.");
       const resetting = installationNeedsReset(dir);
       if (resetting) values.role = values.role ?? installationRole(dir);
-      const release = resetting || serviceActive(dir) && (0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime")) ? () => {
+      const release = resetting || serviceActive(dir) && (0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime")) ? () => {
       } : acquireProcessLease(combinedLeasePath(dir));
       let alias;
       let installedVersion;
@@ -9949,7 +10200,7 @@ Save this password; it is shown once.`);
         if (resetting) {
           console.log("Old installation state detected. Resetting configuration and history, then installing the replacement\u2026");
           validateSetupOptions({ role: values.role, port: values.port, origin: values.origin, socket: values.socket });
-          const source = values.from ? /^[./]/.test(values.from) ? (0, import_node_path20.resolve)(values.from) : values.from : void 0;
+          const source = values.from ? /^[./]/.test(values.from) ? (0, import_node_path21.resolve)(values.from) : values.from : void 0;
           const stage = stagePackage(ROOT, dir, source);
           let setup;
           try {
@@ -9959,26 +10210,27 @@ Save this password; it is shown once.`);
               setup: { role: values.role, port: values.port, origin: values.origin, socket: values.socket }
             });
           } catch (error2) {
-            (0, import_node_fs19.rmSync)(stage, { recursive: true, force: true });
+            (0, import_node_fs20.rmSync)(stage, { recursive: true, force: true });
             throw error2;
           }
           announce(setup, dir);
-          installedVersion = runtimeVersion((0, import_node_path20.join)(dir, "runtime"));
+          installedVersion = runtimeVersion((0, import_node_path21.join)(dir, "runtime"));
           writeRuntimeState(dir, { ...readRuntimeState(dir) ?? emptyRuntimeState(dir), currentVersion: installedVersion });
         } else {
           const setup = initialize(dir, { role: values.role, port: values.port, origin: values.origin, socket: values.socket });
           announce(setup, dir);
-          if ((0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime"))) {
+          if ((0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime"))) {
             if (values.from) throw new Error("Runtime already installed. Use rigscope upgrade --from <package>.");
           } else {
             console.log("Installing runtime\u2026");
-            const source = values.from ? /^[./]/.test(values.from) ? (0, import_node_path20.resolve)(values.from) : values.from : void 0;
+            const source = values.from ? /^[./]/.test(values.from) ? (0, import_node_path21.resolve)(values.from) : values.from : void 0;
             const stage = stagePackage(ROOT, dir, source);
             activatePackage(dir, stage);
           }
-          installedVersion = runtimeVersion((0, import_node_path20.join)(dir, "runtime"));
+          installedVersion = runtimeVersion((0, import_node_path21.join)(dir, "runtime"));
           writeRuntimeState(dir, { ...readRuntimeState(dir) ?? emptyRuntimeState(dir), currentVersion: installedVersion });
         }
+        recordMachineDataTransition(dir, installedVersion);
         writeService(dir);
         alias = installAlias(dir, ROOT);
         const installedConfig = readSetup(dir);
@@ -10024,7 +10276,7 @@ Services: ${components2.map((target) => unitName(dir, target)).join(", ")}`);
       }
       const startup = startupStatus(dir);
       console.log(`Startup: ${!startup.enabled ? "manual" : startup.linger ? "at boot; continues after logout" : "at login; use install --boot to continue after logout"}`);
-      if (!(process.env.PATH ?? "").split(":").includes((0, import_node_path20.resolve)(alias, ".."))) console.log(`Add ${(0, import_node_path20.resolve)(alias, "..")} to PATH, or use the command path above.`);
+      if (!(process.env.PATH ?? "").split(":").includes((0, import_node_path21.resolve)(alias, ".."))) console.log(`Add ${(0, import_node_path21.resolve)(alias, "..")} to PATH, or use the command path above.`);
       return 0;
     }
     if (command === "doctor") {
@@ -10040,7 +10292,7 @@ Services: ${components2.map((target) => unitName(dir, target)).join(", ")}`);
     const config = readSetup(dir);
     if (!config) {
       if (command === "status") {
-        console.log(`Rigscope ${JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path20.join)(ROOT, "package.json"), "utf8")).version}
+        console.log(`Rigscope ${JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path21.join)(ROOT, "package.json"), "utf8")).version}
 No user installation.
 Install background monitoring: rigscope install --boot
 Connect to a hub: rigscope install --role collector --boot
@@ -10061,25 +10313,25 @@ ${bold("Components")}:`);
         console.log(`  ${bold(label2(target))}: ${componentEnabled(config, target) ? "enabled" : "disabled"}, ${colorize(state2, service.active ? "green" : "gray")}, startup ${service.enabled ? "on" : "off"}${service.installed ? "" : " (not installed)"}`);
         if (service.active && service.execMainPid) console.log(`    PID ${service.execMainPid}`);
       }
-      console.log(`Configuration: ${(0, import_node_path20.join)(dir, "config.json")}
+      console.log(`Configuration: ${(0, import_node_path21.join)(dir, "config.json")}
 Startup: ${!startup.enabled ? "manual" : startup.linger ? "at boot; continues after logout" : "at login only"}
-CLI version: ${JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path20.join)(ROOT, "package.json"), "utf8")).version}`);
-      if ((0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime"))) {
+CLI version: ${JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path21.join)(ROOT, "package.json"), "utf8")).version}`);
+      if ((0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime"))) {
         try {
-          console.log(`Runtime: rigscope ${runtimeVersion((0, import_node_path20.join)(dir, "runtime"))}`);
+          console.log(`Runtime: rigscope ${runtimeVersion((0, import_node_path21.join)(dir, "runtime"))}`);
         } catch {
           console.log("Runtime: invalid (run rigscope doctor)");
         }
       }
-      if ((0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime-previous"))) {
+      if ((0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime-previous"))) {
         try {
-          console.log(`Previous runtime: rigscope ${runtimeVersion((0, import_node_path20.join)(dir, "runtime-previous"))}`);
+          console.log(`Previous runtime: rigscope ${runtimeVersion((0, import_node_path21.join)(dir, "runtime-previous"))}`);
         } catch {
           console.log("Previous runtime: invalid");
         }
       }
       const releaseState = readRuntimeState(dir);
-      const paired = releaseState ? Object.values(releaseState.backups).filter((record) => (0, import_node_fs19.existsSync)(record.path)) : [];
+      const paired = releaseState ? Object.values(releaseState.backups).filter((record) => (0, import_node_fs20.existsSync)(record.path)) : [];
       if (paired.length > 0) console.log(`Paired database backups: ${paired.length}`);
       const hubConfigured2 = config.users.length > 0;
       if (hubConfigured2) console.log(`Hub: ${config.origin ?? `http://127.0.0.1:${config.port}`}`);
@@ -10088,8 +10340,8 @@ CLI version: ${JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_pat
         console.log(`Health: ${health.ok ? "ok" : health.error}
 Running version: ${health.body?.version ?? "unavailable"}`);
       }
-      const state = (0, import_node_path20.join)(dir, "collector", "state.json");
-      if ((0, import_node_fs19.existsSync)(state)) {
+      const state = (0, import_node_path21.join)(dir, "collector", "state.json");
+      if ((0, import_node_fs20.existsSync)(state)) {
         const saved = JSON.parse(readPrivate(state));
         console.log(`Destinations: ${saved.destinations.length}/8${saved.destinations.length === 0 ? " (awaiting connection)" : ""}`);
         for (const destination of saved.destinations) console.log(`  ${destination.url}`);
@@ -10139,9 +10391,9 @@ Running version: ${health.body?.version ?? "unavailable"}`);
       return 0;
     }
     if (command === "upgrade") {
-      if (!(0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "runtime"))) throw new Error("Install a managed runtime before upgrading.");
+      if (!(0, import_node_fs20.existsSync)((0, import_node_path21.join)(dir, "runtime"))) throw new Error("Install a managed runtime before upgrading.");
       console.log("Staging upgrade\u2026");
-      const source = values.from ? /^[./]/.test(values.from) ? (0, import_node_path20.resolve)(values.from) : values.from : "rigscope@latest";
+      const source = values.from ? /^[./]/.test(values.from) ? (0, import_node_path21.resolve)(values.from) : values.from : "rigscope@latest";
       const report = await upgradeInstallation({
         root: ROOT,
         dir,
@@ -10153,13 +10405,14 @@ Running version: ${health.body?.version ?? "unavailable"}`);
       if (report.schemaVersion !== null) console.log(`Database schema: ${report.schemaVersion}`);
       if (report.verification.health) console.log(`Health: ${report.verification.health.attempts} probe(s) in ${report.verification.health.elapsedMs}ms`);
       else console.log("Health: skipped because the service was inactive; start it explicitly.");
+      printMachineDataOutcome2(report.machineHistory);
       return 0;
     }
     if (command === "rollback") {
       console.log("Rolling back\u2026");
       const report = await rollbackInstallation({
         dir,
-        backup: values.backup ? (0, import_node_path20.resolve)(values.backup) : void 0,
+        backup: values.backup ? (0, import_node_path21.resolve)(values.backup) : void 0,
         healthDeadlineMs: healthDeadline(values.timeout)
       });
       printSuccess(`Rolled back: rigscope ${report.version} (previous ${report.previousVersion}).`);
@@ -10177,7 +10430,7 @@ Running version: ${health.body?.version ?? "unavailable"}`);
       if (!componentEnabled(config, "hub")) throw new Error("This installation has no hub component.");
       const password = recoveryPassword;
       const report = await recoverAdminPassword({
-        database: (0, import_node_path20.join)(dir, "hub", "telemetry.sqlite"),
+        database: (0, import_node_path21.join)(dir, "hub", "telemetry.sqlite"),
         username: values.user ?? "owner",
         password,
         enable: values.enable === true