modelstat 0.0.10 → 0.0.13

package/dist/cli.mjs

@@ -1,13 +1,42 @@
 #!/usr/bin/env node
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // ../../packages/parsers/src/types.ts
 var init_types = __esm({
@@ -36,7 +65,7 @@ var init_git = __esm({
 });
 
 // ../../packages/core/src/enums.ts
-var TOOLS, PROVIDERS, WORK_TYPES, IDENTITY_OWNER_SCOPES, INSTALL_METHODS, OS_FAMILIES, EVENT_KINDS, CLASSIFICATION_CONFIDENCE;
+var TOOLS, PROVIDERS, IDENTITY_OWNER_SCOPES, INSTALL_METHODS, OS_FAMILIES, EVENT_KINDS, COMPANION_PHASES, CLASSIFICATION_CONFIDENCE;
 var init_enums = __esm({
   "../../packages/core/src/enums.ts"() {
     "use strict";
@@ -89,20 +118,6 @@ var init_enums = __esm({
       "ollama_local",
       "unknown"
     ];
-    WORK_TYPES = [
-      "planning",
-      "implementation",
-      "debugging",
-      "review",
-      "refactoring",
-      "testing",
-      "docs",
-      "devops",
-      "research",
-      "ops",
-      "chat",
-      "misc"
-    ];
     IDENTITY_OWNER_SCOPES = ["org", "personal", "unassigned"];
     INSTALL_METHODS = [
       "homebrew",
@@ -134,6 +149,17 @@ var init_enums = __esm({
       "tool_result",
       "summary"
     ];
+    COMPANION_PHASES = [
+      "starting",
+      "discovering",
+      "idle",
+      "scanning",
+      "processing",
+      "uploading",
+      "watching",
+      "offline",
+      "error"
+    ];
     CLASSIFICATION_CONFIDENCE = [
       "hard",
       // deterministic (from git remote, filenames, etc.)
@@ -4265,7 +4291,7 @@ var init_zod = __esm({
 });
 
 // ../../packages/core/src/schemas.ts
-var TokenUsage, TaxonomyHint, SessionSegmentSummary, SessionSummary, GitContext, RawEvent, IngestBatch, DeviceEnrollment, DeviceSelfRegister, DeviceClaimRequest, ProcessingMetadata, RedactionPolicy, DetectedInstallation, DetectedIdentity, DiscoveryReport, ClassificationConfidenceEnum;
+var TokenUsage, GitContext, RawEvent, RedactionReport, TaxonomyHintRooted, Segment, IngestBatch, HeartbeatPayload, DeviceEnrollment, DeviceSelfRegister, DeviceClaimRequest, ProcessingMetadata, RedactionPolicy, DetectedInstallation, DetectedIdentity, DiscoveryReport, ClassificationConfidenceEnum;
 var init_schemas = __esm({
   "../../packages/core/src/schemas.ts"() {
     "use strict";
@@ -4279,52 +4305,12 @@ var init_schemas = __esm({
       /** Present on reasoning-model turns (Codex gpt-5.4, Claude extended thinking). */
       reasoning: external_exports.number().int().nonnegative().default(0)
     });
-    TaxonomyHint = external_exports.object({
-      root_key: external_exports.string().max(40),
-      name: external_exports.string().max(120),
-      /** Agent's confidence, 0..1. Server may override. */
-      confidence: external_exports.number().min(0).max(1).default(0.7)
-    });
-    SessionSegmentSummary = external_exports.object({
-      /** Order within the parent session (0-based). */
-      idx: external_exports.number().int().nonnegative(),
-      started_at: external_exports.string().datetime({ offset: true }).nullable(),
-      ended_at: external_exports.string().datetime({ offset: true }).nullable(),
-      /** Per-segment tokens. Must sum to session totals (the agent should
-       * enforce this; the server double-checks). */
-      tokens: TokenUsage,
-      /** First/last turn index this segment covers, for debugging. */
-      turn_range: external_exports.tuple([external_exports.number().int(), external_exports.number().int()]).nullable().optional(),
-      goal: external_exports.string().max(280).nullable(),
-      feature: external_exports.string().max(120).nullable(),
-      work_type_hint: external_exports.enum(WORK_TYPES).nullable(),
-      domain_keywords: external_exports.array(external_exports.string().max(40)).max(16).default([]),
-      /** Hints this segment maps to. May span multiple roots (one segment
-       * can be "Projects: modelstat" + "Work types: Bug investigation"
-       * + "Domains: ingestion pipeline" simultaneously). */
-      taxonomy_hints: external_exports.array(TaxonomyHint).max(20).default([])
-    });
-    SessionSummary = external_exports.object({
-      goal: external_exports.string().max(280).nullable(),
-      feature_hint: external_exports.string().max(120).nullable(),
-      work_type_hint: external_exports.enum(WORK_TYPES).nullable(),
-      domain_keywords: external_exports.array(external_exports.string().max(40)).max(16).default([]),
-      /** One or more segments. If empty, the ingest endpoint will synth a
-       * single segment from the session's aggregate tokens. */
-      segments: external_exports.array(SessionSegmentSummary).max(64).default([]),
-      /** Counts only — the actual content never leaves the device. */
-      redaction_report: external_exports.object({
-        secrets_found: external_exports.number().int().nonnegative().default(0),
-        emails_redacted: external_exports.number().int().nonnegative().default(0),
-        paths_redacted_absolute: external_exports.number().int().nonnegative().default(0)
-      }).default({ secrets_found: 0, emails_redacted: 0, paths_redacted_absolute: 0 })
-    });
     GitContext = external_exports.object({
       remote_url: external_exports.string().nullable(),
       remote_host: external_exports.string().nullable(),
       // "github.com"
       remote_slug: external_exports.string().nullable(),
-      // "0xflair/chainvisor"
+      // "org/repo"
       branch: external_exports.string().nullable(),
       commit_sha: external_exports.string().nullable()
     });
@@ -4355,15 +4341,49 @@ var init_schemas = __esm({
       source_file: external_exports.string().max(1024).nullable(),
       source_byte_offset: external_exports.number().int().nonnegative().nullable()
     });
+    RedactionReport = external_exports.object({
+      secrets_found: external_exports.number().int().nonnegative().default(0),
+      emails_redacted: external_exports.number().int().nonnegative().default(0),
+      paths_redacted_absolute: external_exports.number().int().nonnegative().default(0)
+    });
+    TaxonomyHintRooted = external_exports.object({
+      root_key: external_exports.string().max(60),
+      name: external_exports.string().max(120),
+      confidence: external_exports.number().min(0).max(1).default(0.7),
+      /** Optional free-text reason the companion attached this tag — surfaces
+       * in the audit log so the user can see "why was this tagged X?" */
+      reason: external_exports.string().max(200).optional()
+    });
+    Segment = external_exports.object({
+      /** sha256-based deterministic id — see @modelstat/core/ids.ts segmentId(). */
+      segment_id: external_exports.string().max(64),
+      session_id: external_exports.string().max(120),
+      tool: external_exports.enum(TOOLS),
+      started_at: external_exports.string().datetime({ offset: true }),
+      ended_at: external_exports.string().datetime({ offset: true }),
+      /** Pre-redacted abstract, ≤ 512 chars. Never contains PII. */
+      abstract: external_exports.string().max(512),
+      /** Tokens spent inside this segment only. */
+      tokens: TokenUsage,
+      /** Tags with strongly-typed root keys. Server merges with its own
+       * classifier output and files any novel names as taxonomy proposals. */
+      tags: external_exports.array(TaxonomyHintRooted).max(40).default([]),
+      /** Counts of what was stripped. */
+      redaction: RedactionReport,
+      /** `source_event_id`s covered by this segment. Used for dedupe + replay. */
+      source_event_ids: external_exports.array(external_exports.string()).max(2e3),
+      /** Optional embedding of the abstract (BGE-small-en-v1.5, 384 dims).
+       * Present when the companion has an Embedder adapter configured.
+       * Reserved for server-side similarity / clustering. */
+      abstract_embedding: external_exports.array(external_exports.number()).length(384).optional()
+    });
     IngestBatch = external_exports.object({
       batch_id: external_exports.string(),
       // ULID
       device_id: external_exports.string(),
       agent_version: external_exports.string().max(40),
-      schema_version: external_exports.literal(1),
       events: external_exports.array(RawEvent).max(1e4),
-      /** Optional per-session summaries, indexed by `session_id`. */
-      session_summaries: external_exports.record(external_exports.string(), SessionSummary).optional(),
+      segments: external_exports.array(Segment).max(2e3).default([]),
       /** Optional per-session metadata hint: which installation produced them, etc. */
       session_installs: external_exports.record(
         external_exports.string(),
@@ -4373,6 +4393,17 @@ var init_schemas = __esm({
         })
       ).optional()
     });
+    HeartbeatPayload = external_exports.object({
+      device_id: external_exports.string(),
+      status: external_exports.enum(COMPANION_PHASES),
+      message: external_exports.string().max(240).nullable(),
+      progress_done: external_exports.number().int().nonnegative().default(0),
+      progress_total: external_exports.number().int().nonnegative().default(0),
+      queue_size: external_exports.number().int().nonnegative().default(0),
+      stats: external_exports.record(external_exports.string(), external_exports.unknown()).default({}),
+      last_event_at: external_exports.string().datetime({ offset: true }).nullable(),
+      agent_version: external_exports.string().max(40)
+    });
     DeviceEnrollment = external_exports.object({
       machine_id: external_exports.string(),
       // stable, platform-provided
@@ -4454,8 +4485,17 @@ var init_schemas = __esm({
 
 // ../../packages/core/src/ids.ts
 import { ulid } from "ulid";
-function sourceEventId(deviceId, sourceFilePath, byteOffset) {
-  const s = `${deviceId}::${sourceFilePath}::${byteOffset}`;
+function sourceEventId(deviceId, sourceOrFilePath, byteOffsetMaybe) {
+  let key;
+  if (typeof sourceOrFilePath === "string") {
+    const byteOffset = byteOffsetMaybe ?? 0;
+    key = `fs::${sourceOrFilePath}::${byteOffset}`;
+  } else if ("file" in sourceOrFilePath) {
+    key = `fs::${sourceOrFilePath.file}::${sourceOrFilePath.byteOffset}`;
+  } else {
+    key = `web::${sourceOrFilePath.host}::${sourceOrFilePath.conversationId}::${sourceOrFilePath.messageId}`;
+  }
+  const s = `${deviceId}::${key}`;
   let h = 5381n;
   for (let i = 0; i < s.length; i++) {
     h = h * 33n ^ BigInt(s.charCodeAt(i));
@@ -4463,16 +4503,98 @@ function sourceEventId(deviceId, sourceFilePath, byteOffset) {
   }
   return `evt_${h.toString(36)}`;
 }
+function segmentId(sessionId, startedAtMs, endedAtMs, sourceEventIds) {
+  const sorted = [...sourceEventIds].sort().join(",");
+  const s = `${sessionId}|${startedAtMs}|${endedAtMs}|${sorted}`;
+  let h = 5381n;
+  for (let i = 0; i < s.length; i++) {
+    h = h * 33n ^ BigInt(s.charCodeAt(i));
+    h &= 0xffffffffffffffffn;
+  }
+  return `seg_${h.toString(36)}`;
+}
+var batchId;
 var init_ids = __esm({
   "../../packages/core/src/ids.ts"() {
     "use strict";
+    batchId = () => ulid();
   }
 });
 
 // ../../packages/core/src/redact.ts
+function entropy(s) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const c of s) freq.set(c, (freq.get(c) ?? 0) + 1);
+  let h = 0;
+  for (const n of freq.values()) {
+    const p = n / s.length;
+    h -= p * Math.log2(p);
+  }
+  return h;
+}
+function redact(text, repoRootAbs) {
+  let out = text;
+  const counts = {
+    secrets_found: 0,
+    emails_redacted: 0,
+    paths_redacted_absolute: 0
+  };
+  for (const { name, pattern } of SECRET_PATTERNS) {
+    out = out.replace(pattern, () => {
+      counts.secrets_found += 1;
+      return `[REDACTED:${name}]`;
+    });
+  }
+  out = out.replace(TOKEN_CANDIDATE, (match) => {
+    if (/^[a-f0-9]+$/i.test(match)) return match;
+    if (/^[A-Z]+$/.test(match)) return match;
+    const hasLetter = /[A-Za-z]/.test(match);
+    const hasDigit = /\d/.test(match);
+    const hasUpper = /[A-Z]/.test(match);
+    const hasLower = /[a-z]/.test(match);
+    if (!(hasLetter && hasDigit && hasUpper && hasLower)) return match;
+    if (entropy(match) < 3.6) return match;
+    counts.secrets_found += 1;
+    return `[REDACTED:hi-entropy]`;
+  });
+  out = out.replace(EMAIL_PATTERN, () => {
+    counts.emails_redacted += 1;
+    return "[REDACTED:email]";
+  });
+  const pathReplacer = (match) => {
+    if (repoRootAbs && match.startsWith(repoRootAbs)) {
+      return match.slice(repoRootAbs.length).replace(/^\/+/, "./");
+    }
+    counts.paths_redacted_absolute += 1;
+    return "[REDACTED:abs-path]";
+  };
+  out = out.replace(ABSOLUTE_PATH_MACOS, pathReplacer);
+  out = out.replace(ABSOLUTE_PATH_LINUX, pathReplacer);
+  return { text: out, counts };
+}
+var SECRET_PATTERNS, EMAIL_PATTERN, ABSOLUTE_PATH_MACOS, ABSOLUTE_PATH_LINUX, TOKEN_CANDIDATE;
 var init_redact = __esm({
   "../../packages/core/src/redact.ts"() {
     "use strict";
+    SECRET_PATTERNS = [
+      { name: "anthropic_key", pattern: /sk-ant-[A-Za-z0-9_-]{20,}/g },
+      { name: "openai_key", pattern: /sk-(?:proj-)?[A-Za-z0-9_-]{20,}/g },
+      { name: "google_api_key", pattern: /AIza[0-9A-Za-z_-]{35}/g },
+      { name: "aws_access_key", pattern: /AKIA[0-9A-Z]{16}/g },
+      { name: "aws_secret_key", pattern: /(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])/g },
+      { name: "github_pat", pattern: /ghp_[A-Za-z0-9]{36}/g },
+      { name: "github_oauth", pattern: /gho_[A-Za-z0-9]{36}/g },
+      { name: "github_app", pattern: /gh[sur]_[A-Za-z0-9]{36}/g },
+      { name: "slack_token", pattern: /xox[baprs]-[A-Za-z0-9-]{10,}/g },
+      { name: "stripe_live_key", pattern: /sk_live_[A-Za-z0-9]{24,}/g },
+      { name: "stripe_test_key", pattern: /sk_test_[A-Za-z0-9]{24,}/g },
+      { name: "jwt", pattern: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g },
+      { name: "private_key_header", pattern: /-----BEGIN [A-Z ]+PRIVATE KEY-----/g }
+    ];
+    EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+    ABSOLUTE_PATH_MACOS = /\/Users\/[^\s"'`)]+/g;
+    ABSOLUTE_PATH_LINUX = /\/home\/[^\s"'`)]+/g;
+    TOKEN_CANDIDATE = /[A-Za-z0-9/+=_-]{32,}/g;
   }
 });
 
@@ -4783,144 +4905,2290 @@ var init_codex = __esm({
   }
 });
 
-// ../../packages/parsers/src/cursor/index.ts
-import Database from "better-sqlite3";
-var init_cursor = __esm({
-  "../../packages/parsers/src/cursor/index.ts"() {
+// ../../node_modules/.pnpm/sql.js@1.14.1/node_modules/sql.js/dist/sql-wasm.js
+var require_sql_wasm = __commonJS({
+  "../../node_modules/.pnpm/sql.js@1.14.1/node_modules/sql.js/dist/sql-wasm.js"(exports, module) {
     "use strict";
-    init_src();
-  }
-});
-
-// ../../packages/parsers/src/discovery/index.ts
-import { execFile as execFile2, execSync } from "child_process";
-import { existsSync as existsSync2, statSync } from "fs";
-import { homedir, platform } from "os";
-import { join, resolve as resolve2 } from "path";
-import { promisify as promisify2 } from "util";
-async function discover(options = {}) {
-  const os = platform() === "darwin" ? "macos" : "linux";
-  const skip = new Set(options.skip ?? []);
-  const installations = [];
-  const identities = [];
-  for (const spec of SOURCES) {
-    const candidates = /* @__PURE__ */ new Set();
-    for (const raw of spec.dataDirs[os] ?? []) candidates.add(expandPath(raw));
-    for (const env of spec.dataDirEnv ?? []) {
-      const v = process.env[env];
-      if (v) candidates.add(v);
-    }
-    for (const extra of options.extraDataDirs?.[spec.tool] ?? []) candidates.add(expandPath(extra));
-    for (const p of candidates) {
-      if (existsSync2(p) && statSync(p).isDirectory()) {
-        installations.push({
-          tool: spec.tool,
-          install_method: "manual",
-          binary_path: null,
-          data_dir: p,
-          version: null,
-          detected_via: ["known_path"]
+    var initSqlJsPromise = void 0;
+    var initSqlJs2 = function(moduleConfig) {
+      if (initSqlJsPromise) {
+        return initSqlJsPromise;
+      }
+      initSqlJsPromise = new Promise(function(resolveModule, reject) {
+        var Module = typeof moduleConfig !== "undefined" ? moduleConfig : {};
+        var originalOnAbortFunction = Module["onAbort"];
+        Module["onAbort"] = function(errorThatCausedAbort) {
+          reject(new Error(errorThatCausedAbort));
+          if (originalOnAbortFunction) {
+            originalOnAbortFunction(errorThatCausedAbort);
+          }
+        };
+        Module["postRun"] = Module["postRun"] || [];
+        Module["postRun"].push(function() {
+          resolveModule(Module);
         });
-      }
-    }
-  }
-  if (!skip.has("binaryWalk")) {
-    const binDirs = binaryLookupDirs(os);
-    for (const spec of SOURCES) {
-      for (const bin of spec.binaries ?? []) {
-        for (const dir of binDirs) {
-          const p = join(dir, bin);
-          if (existsSync2(p)) {
-            const version = await safeVersionProbe(p);
-            installations.push({
-              tool: spec.tool,
-              install_method: classifyInstallMethod(p, os),
-              binary_path: p,
-              data_dir: null,
-              version,
-              detected_via: ["binary_walk"]
+        module = void 0;
+        var k;
+        k ||= typeof Module != "undefined" ? Module : {};
+        var aa = !!globalThis.window, ba = !!globalThis.WorkerGlobalScope, ca = globalThis.process?.versions?.node && "renderer" != globalThis.process?.type;
+        k.onRuntimeInitialized = function() {
+          function a(f, l) {
+            switch (typeof l) {
+              case "boolean":
+                bc(f, l ? 1 : 0);
+                break;
+              case "number":
+                cc(f, l);
+                break;
+              case "string":
+                dc(f, l, -1, -1);
+                break;
+              case "object":
+                if (null === l) lb(f);
+                else if (null != l.length) {
+                  var n = da(l.length);
+                  m.set(l, n);
+                  ec(f, n, l.length, -1);
+                  ea(n);
+                } else sa(f, "Wrong API use : tried to return a value of an unknown type (" + l + ").", -1);
+                break;
+              default:
+                lb(f);
+            }
+          }
+          function b(f, l) {
+            for (var n = [], p = 0; p < f; p += 1) {
+              var u = r(l + 4 * p, "i32"), v = fc(u);
+              if (1 === v || 2 === v) u = gc(u);
+              else if (3 === v) u = hc(u);
+              else if (4 === v) {
+                v = u;
+                u = ic(v);
+                v = jc(v);
+                for (var K = new Uint8Array(u), I = 0; I < u; I += 1) K[I] = m[v + I];
+                u = K;
+              } else u = null;
+              n.push(u);
+            }
+            return n;
+          }
+          function c(f, l) {
+            this.Qa = f;
+            this.db = l;
+            this.Oa = 1;
+            this.mb = [];
+          }
+          function d(f, l) {
+            this.db = l;
+            this.fb = fa(f);
+            if (null === this.fb) throw Error("Unable to allocate memory for the SQL string");
+            this.lb = this.fb;
+            this.$a = this.sb = null;
+          }
+          function e(f) {
+            this.filename = "dbfile_" + (4294967295 * Math.random() >>> 0);
+            if (null != f) {
+              var l = this.filename, n = "/", p = l;
+              n && (n = "string" == typeof n ? n : ha(n), p = l ? ia(n + "/" + l) : n);
+              l = ja(true, true);
+              p = ka(
+                p,
+                l
+              );
+              if (f) {
+                if ("string" == typeof f) {
+                  n = Array(f.length);
+                  for (var u = 0, v = f.length; u < v; ++u) n[u] = f.charCodeAt(u);
+                  f = n;
+                }
+                la(p, l | 146);
+                n = ma(p, 577);
+                na(n, f, 0, f.length, 0);
+                oa(n);
+                la(p, l);
+              }
+            }
+            this.handleError(q(this.filename, g));
+            this.db = r(g, "i32");
+            ob(this.db);
+            this.gb = {};
+            this.Sa = {};
+          }
+          var g = y(4), h = k.cwrap, q = h("sqlite3_open", "number", ["string", "number"]), w = h("sqlite3_close_v2", "number", ["number"]), t = h("sqlite3_exec", "number", ["number", "string", "number", "number", "number"]), x = h("sqlite3_changes", "number", ["number"]), D = h(
+            "sqlite3_prepare_v2",
+            "number",
+            ["number", "string", "number", "number", "number"]
+          ), pb = h("sqlite3_sql", "string", ["number"]), lc = h("sqlite3_normalized_sql", "string", ["number"]), qb = h("sqlite3_prepare_v2", "number", ["number", "number", "number", "number", "number"]), mc = h("sqlite3_bind_text", "number", ["number", "number", "number", "number", "number"]), rb = h("sqlite3_bind_blob", "number", ["number", "number", "number", "number", "number"]), nc = h("sqlite3_bind_double", "number", ["number", "number", "number"]), oc = h("sqlite3_bind_int", "number", [
+            "number",
+            "number",
+            "number"
+          ]), pc = h("sqlite3_bind_parameter_index", "number", ["number", "string"]), qc = h("sqlite3_step", "number", ["number"]), rc = h("sqlite3_errmsg", "string", ["number"]), sc = h("sqlite3_column_count", "number", ["number"]), tc = h("sqlite3_data_count", "number", ["number"]), uc = h("sqlite3_column_double", "number", ["number", "number"]), sb = h("sqlite3_column_text", "string", ["number", "number"]), vc = h("sqlite3_column_blob", "number", ["number", "number"]), wc = h("sqlite3_column_bytes", "number", ["number", "number"]), xc = h(
+            "sqlite3_column_type",
+            "number",
+            ["number", "number"]
+          ), yc = h("sqlite3_column_name", "string", ["number", "number"]), zc = h("sqlite3_reset", "number", ["number"]), Ac = h("sqlite3_clear_bindings", "number", ["number"]), Bc = h("sqlite3_finalize", "number", ["number"]), tb = h("sqlite3_create_function_v2", "number", "number string number number number number number number number".split(" ")), fc = h("sqlite3_value_type", "number", ["number"]), ic = h("sqlite3_value_bytes", "number", ["number"]), hc = h("sqlite3_value_text", "string", ["number"]), jc = h(
+            "sqlite3_value_blob",
+            "number",
+            ["number"]
+          ), gc = h("sqlite3_value_double", "number", ["number"]), cc = h("sqlite3_result_double", "", ["number", "number"]), lb = h("sqlite3_result_null", "", ["number"]), dc = h("sqlite3_result_text", "", ["number", "string", "number", "number"]), ec = h("sqlite3_result_blob", "", ["number", "number", "number", "number"]), bc = h("sqlite3_result_int", "", ["number", "number"]), sa = h("sqlite3_result_error", "", ["number", "string", "number"]), ub = h("sqlite3_aggregate_context", "number", ["number", "number"]), ob = h(
+            "RegisterExtensionFunctions",
+            "number",
+            ["number"]
+          ), vb = h("sqlite3_update_hook", "number", ["number", "number", "number"]);
+          c.prototype.bind = function(f) {
+            if (!this.Qa) throw "Statement closed";
+            this.reset();
+            return Array.isArray(f) ? this.Gb(f) : null != f && "object" === typeof f ? this.Hb(f) : true;
+          };
+          c.prototype.step = function() {
+            if (!this.Qa) throw "Statement closed";
+            this.Oa = 1;
+            var f = qc(this.Qa);
+            switch (f) {
+              case 100:
+                return true;
+              case 101:
+                return false;
+              default:
+                throw this.db.handleError(f);
+            }
+          };
+          c.prototype.Ab = function(f) {
+            null == f && (f = this.Oa, this.Oa += 1);
+            return uc(this.Qa, f);
+          };
+          c.prototype.Ob = function(f) {
+            null == f && (f = this.Oa, this.Oa += 1);
+            f = sb(this.Qa, f);
+            if ("function" !== typeof BigInt) throw Error("BigInt is not supported");
+            return BigInt(f);
+          };
+          c.prototype.Tb = function(f) {
+            null == f && (f = this.Oa, this.Oa += 1);
+            return sb(this.Qa, f);
+          };
+          c.prototype.getBlob = function(f) {
+            null == f && (f = this.Oa, this.Oa += 1);
+            var l = wc(this.Qa, f);
+            f = vc(this.Qa, f);
+            for (var n = new Uint8Array(l), p = 0; p < l; p += 1) n[p] = m[f + p];
+            return n;
+          };
+          c.prototype.get = function(f, l) {
+            l = l || {};
+            null != f && this.bind(f) && this.step();
+            f = [];
+            for (var n = tc(this.Qa), p = 0; p < n; p += 1) switch (xc(this.Qa, p)) {
+              case 1:
+                var u = l.useBigInt ? this.Ob(p) : this.Ab(p);
+                f.push(u);
+                break;
+              case 2:
+                f.push(this.Ab(p));
+                break;
+              case 3:
+                f.push(this.Tb(p));
+                break;
+              case 4:
+                f.push(this.getBlob(p));
+                break;
+              default:
+                f.push(null);
+            }
+            return f;
+          };
+          c.prototype.qb = function() {
+            for (var f = [], l = sc(this.Qa), n = 0; n < l; n += 1) f.push(yc(this.Qa, n));
+            return f;
+          };
+          c.prototype.zb = function(f, l) {
+            f = this.get(f, l);
+            l = this.qb();
+            for (var n = {}, p = 0; p < l.length; p += 1) n[l[p]] = f[p];
+            return n;
+          };
+          c.prototype.Sb = function() {
+            return pb(this.Qa);
+          };
+          c.prototype.Pb = function() {
+            return lc(this.Qa);
+          };
+          c.prototype.run = function(f) {
+            null != f && this.bind(f);
+            this.step();
+            return this.reset();
+          };
+          c.prototype.wb = function(f, l) {
+            null == l && (l = this.Oa, this.Oa += 1);
+            f = fa(f);
+            this.mb.push(f);
+            this.db.handleError(mc(this.Qa, l, f, -1, 0));
+          };
+          c.prototype.Fb = function(f, l) {
+            null == l && (l = this.Oa, this.Oa += 1);
+            var n = da(f.length);
+            m.set(f, n);
+            this.mb.push(n);
+            this.db.handleError(rb(this.Qa, l, n, f.length, 0));
+          };
+          c.prototype.vb = function(f, l) {
+            null == l && (l = this.Oa, this.Oa += 1);
+            this.db.handleError((f === (f | 0) ? oc : nc)(
+              this.Qa,
+              l,
+              f
+            ));
+          };
+          c.prototype.Ib = function(f) {
+            null == f && (f = this.Oa, this.Oa += 1);
+            rb(this.Qa, f, 0, 0, 0);
+          };
+          c.prototype.xb = function(f, l) {
+            null == l && (l = this.Oa, this.Oa += 1);
+            switch (typeof f) {
+              case "string":
+                this.wb(f, l);
+                return;
+              case "number":
+                this.vb(f, l);
+                return;
+              case "bigint":
+                this.wb(f.toString(), l);
+                return;
+              case "boolean":
+                this.vb(f + 0, l);
+                return;
+              case "object":
+                if (null === f) {
+                  this.Ib(l);
+                  return;
+                }
+                if (null != f.length) {
+                  this.Fb(f, l);
+                  return;
+                }
+            }
+            throw "Wrong API use : tried to bind a value of an unknown type (" + f + ").";
+          };
+          c.prototype.Hb = function(f) {
+            var l = this;
+            Object.keys(f).forEach(function(n) {
+              var p = pc(l.Qa, n);
+              0 !== p && l.xb(f[n], p);
+            });
+            return true;
+          };
+          c.prototype.Gb = function(f) {
+            for (var l = 0; l < f.length; l += 1) this.xb(f[l], l + 1);
+            return true;
+          };
+          c.prototype.reset = function() {
+            this.freemem();
+            return 0 === Ac(this.Qa) && 0 === zc(this.Qa);
+          };
+          c.prototype.freemem = function() {
+            for (var f; void 0 !== (f = this.mb.pop()); ) ea(f);
+          };
+          c.prototype.Ya = function() {
+            this.freemem();
+            var f = 0 === Bc(this.Qa);
+            delete this.db.gb[this.Qa];
+            this.Qa = 0;
+            return f;
+          };
+          d.prototype.next = function() {
+            if (null === this.fb) return { done: true };
+            null !== this.$a && (this.$a.Ya(), this.$a = null);
+            if (!this.db.db) throw this.ob(), Error("Database closed");
+            var f = pa(), l = y(4);
+            qa(g);
+            qa(l);
+            try {
+              this.db.handleError(qb(this.db.db, this.lb, -1, g, l));
+              this.lb = r(l, "i32");
+              var n = r(g, "i32");
+              if (0 === n) return this.ob(), { done: true };
+              this.$a = new c(n, this.db);
+              this.db.gb[n] = this.$a;
+              return { value: this.$a, done: false };
+            } catch (p) {
+              throw this.sb = z(this.lb), this.ob(), p;
+            } finally {
+              ra(f);
+            }
+          };
+          d.prototype.ob = function() {
+            ea(this.fb);
+            this.fb = null;
+          };
+          d.prototype.Qb = function() {
+            return null !== this.sb ? this.sb : z(this.lb);
+          };
+          "function" === typeof Symbol && "symbol" === typeof Symbol.iterator && (d.prototype[Symbol.iterator] = function() {
+            return this;
+          });
+          e.prototype.run = function(f, l) {
+            if (!this.db) throw "Database closed";
+            if (l) {
+              f = this.tb(f, l);
+              try {
+                f.step();
+              } finally {
+                f.Ya();
+              }
+            } else this.handleError(t(this.db, f, 0, 0, g));
+            return this;
+          };
+          e.prototype.exec = function(f, l, n) {
+            if (!this.db) throw "Database closed";
+            var p = null, u = null, v = null;
+            try {
+              v = u = fa(f);
+              var K = y(4);
+              for (f = []; 0 !== r(v, "i8"); ) {
+                qa(g);
+                qa(K);
+                this.handleError(qb(this.db, v, -1, g, K));
+                var I = r(
+                  g,
+                  "i32"
+                );
+                v = r(K, "i32");
+                if (0 !== I) {
+                  var H2 = null;
+                  p = new c(I, this);
+                  for (null != l && p.bind(l); p.step(); ) null === H2 && (H2 = { columns: p.qb(), values: [] }, f.push(H2)), H2.values.push(p.get(null, n));
+                  p.Ya();
+                }
+              }
+              return f;
+            } catch (L) {
+              throw p && p.Ya(), L;
+            } finally {
+              u && ea(u);
+            }
+          };
+          e.prototype.Mb = function(f, l, n, p, u) {
+            "function" === typeof l && (p = n, n = l, l = void 0);
+            f = this.tb(f, l);
+            try {
+              for (; f.step(); ) n(f.zb(null, u));
+            } finally {
+              f.Ya();
+            }
+            if ("function" === typeof p) return p();
+          };
+          e.prototype.tb = function(f, l) {
+            qa(g);
+            this.handleError(D(this.db, f, -1, g, 0));
+            f = r(g, "i32");
+            if (0 === f) throw "Nothing to prepare";
+            var n = new c(f, this);
+            null != l && n.bind(l);
+            return this.gb[f] = n;
+          };
+          e.prototype.Ub = function(f) {
+            return new d(f, this);
+          };
+          e.prototype.Nb = function() {
+            Object.values(this.gb).forEach(function(l) {
+              l.Ya();
             });
+            Object.values(this.Sa).forEach(A);
+            this.Sa = {};
+            this.handleError(w(this.db));
+            var f = ta(this.filename);
+            this.handleError(q(this.filename, g));
+            this.db = r(g, "i32");
+            ob(this.db);
+            return f;
+          };
+          e.prototype.close = function() {
+            null !== this.db && (Object.values(this.gb).forEach(function(f) {
+              f.Ya();
+            }), Object.values(this.Sa).forEach(A), this.Sa = {}, this.Za && (A(this.Za), this.Za = void 0), this.handleError(w(this.db)), ua("/" + this.filename), this.db = null);
+          };
+          e.prototype.handleError = function(f) {
+            if (0 === f) return null;
+            f = rc(this.db);
+            throw Error(f);
+          };
+          e.prototype.Rb = function() {
+            return x(this.db);
+          };
+          e.prototype.Kb = function(f, l) {
+            Object.prototype.hasOwnProperty.call(this.Sa, f) && (A(this.Sa[f]), delete this.Sa[f]);
+            var n = va(function(p, u, v) {
+              u = b(u, v);
+              try {
+                var K = l.apply(null, u);
+              } catch (I) {
+                sa(p, I, -1);
+                return;
+              }
+              a(p, K);
+            }, "viii");
+            this.Sa[f] = n;
+            this.handleError(tb(
+              this.db,
+              f,
+              l.length,
+              1,
+              0,
+              n,
+              0,
+              0,
+              0
+            ));
+            return this;
+          };
+          e.prototype.Jb = function(f, l) {
+            var n = l.init || function() {
+              return null;
+            }, p = l.finalize || function(H2) {
+              return H2;
+            }, u = l.step;
+            if (!u) throw "An aggregate function must have a step function in " + f;
+            var v = {};
+            Object.hasOwnProperty.call(this.Sa, f) && (A(this.Sa[f]), delete this.Sa[f]);
+            l = f + "__finalize";
+            Object.hasOwnProperty.call(this.Sa, l) && (A(this.Sa[l]), delete this.Sa[l]);
+            var K = va(function(H2, L, Pa) {
+              var V = ub(H2, 1);
+              Object.hasOwnProperty.call(v, V) || (v[V] = n());
+              L = b(L, Pa);
+              L = [v[V]].concat(L);
+              try {
+                v[V] = u.apply(null, L);
+              } catch (Dc) {
+                delete v[V], sa(H2, Dc, -1);
+              }
+            }, "viii"), I = va(function(H2) {
+              var L = ub(H2, 1);
+              try {
+                var Pa = p(v[L]);
+              } catch (V) {
+                delete v[L];
+                sa(H2, V, -1);
+                return;
+              }
+              a(H2, Pa);
+              delete v[L];
+            }, "vi");
+            this.Sa[f] = K;
+            this.Sa[l] = I;
+            this.handleError(tb(this.db, f, u.length - 1, 1, 0, 0, K, I, 0));
+            return this;
+          };
+          e.prototype.Zb = function(f) {
+            this.Za && (vb(this.db, 0, 0), A(this.Za), this.Za = void 0);
+            if (!f) return this;
+            this.Za = va(function(l, n, p, u, v) {
+              switch (n) {
+                case 18:
+                  l = "insert";
+                  break;
+                case 23:
+                  l = "update";
+                  break;
+                case 9:
+                  l = "delete";
+                  break;
+                default:
+                  throw "unknown operationCode in updateHook callback: " + n;
+              }
+              p = z(p);
+              u = z(u);
+              if (v > Number.MAX_SAFE_INTEGER) throw "rowId too big to fit inside a Number";
+              f(l, p, u, Number(v));
+            }, "viiiij");
+            vb(this.db, this.Za, 0);
+            return this;
+          };
+          c.prototype.bind = c.prototype.bind;
+          c.prototype.step = c.prototype.step;
+          c.prototype.get = c.prototype.get;
+          c.prototype.getColumnNames = c.prototype.qb;
+          c.prototype.getAsObject = c.prototype.zb;
+          c.prototype.getSQL = c.prototype.Sb;
+          c.prototype.getNormalizedSQL = c.prototype.Pb;
+          c.prototype.run = c.prototype.run;
+          c.prototype.reset = c.prototype.reset;
+          c.prototype.freemem = c.prototype.freemem;
+          c.prototype.free = c.prototype.Ya;
+          d.prototype.next = d.prototype.next;
+          d.prototype.getRemainingSQL = d.prototype.Qb;
+          e.prototype.run = e.prototype.run;
+          e.prototype.exec = e.prototype.exec;
+          e.prototype.each = e.prototype.Mb;
+          e.prototype.prepare = e.prototype.tb;
+          e.prototype.iterateStatements = e.prototype.Ub;
+          e.prototype["export"] = e.prototype.Nb;
+          e.prototype.close = e.prototype.close;
+          e.prototype.handleError = e.prototype.handleError;
+          e.prototype.getRowsModified = e.prototype.Rb;
+          e.prototype.create_function = e.prototype.Kb;
+          e.prototype.create_aggregate = e.prototype.Jb;
+          e.prototype.updateHook = e.prototype.Zb;
+          k.Database = e;
+        };
+        var wa = "./this.program", xa = (a, b) => {
+          throw b;
+        }, ya = globalThis.document?.currentScript?.src;
+        "undefined" != typeof __filename ? ya = __filename : ba && (ya = self.location.href);
+        var za = "", Aa, Ba;
+        if (ca) {
+          var fs2 = __require("fs");
+          za = __dirname + "/";
+          Ba = (a) => {
+            a = Ca(a) ? new URL(a) : a;
+            return fs2.readFileSync(a);
+          };
+          Aa = async (a) => {
+            a = Ca(a) ? new URL(a) : a;
+            return fs2.readFileSync(a, void 0);
+          };
+          1 < process.argv.length && (wa = process.argv[1].replace(/\\/g, "/"));
+          process.argv.slice(2);
+          "undefined" != typeof module && (module.exports = k);
+          xa = (a, b) => {
+            process.exitCode = a;
+            throw b;
+          };
+        } else if (aa || ba) {
+          try {
+            za = new URL(".", ya).href;
+          } catch {
           }
-        }
-      }
-    }
-  }
-  if (!skip.has("appRegistry") && os === "macos") {
-    try {
-      const apps = await macosListApps();
-      for (const spec of SOURCES) {
-        for (const bid of spec.bundleIds ?? []) {
-          const hit = apps.find((a) => a.bundleId === bid);
-          if (hit) {
-            installations.push({
-              tool: spec.tool,
-              install_method: "app_bundle",
-              binary_path: hit.path,
-              data_dir: null,
-              version: hit.version,
-              detected_via: ["app_registry"]
+          ba && (Ba = (a) => {
+            var b = new XMLHttpRequest();
+            b.open("GET", a, false);
+            b.responseType = "arraybuffer";
+            b.send(null);
+            return new Uint8Array(b.response);
+          });
+          Aa = async (a) => {
+            if (Ca(a)) return new Promise((c, d) => {
+              var e = new XMLHttpRequest();
+              e.open("GET", a, true);
+              e.responseType = "arraybuffer";
+              e.onload = () => {
+                200 == e.status || 0 == e.status && e.response ? c(e.response) : d(e.status);
+              };
+              e.onerror = d;
+              e.send(null);
             });
+            var b = await fetch(a, { credentials: "same-origin" });
+            if (b.ok) return b.arrayBuffer();
+            throw Error(b.status + " : " + b.url);
+          };
+        }
+        var Da = console.log.bind(console), B = console.error.bind(console), Ea, Fa = false, Ga, Ca = (a) => a.startsWith("file://"), m, C, Ha, E, F, Ia, Ja, G;
+        function Ka() {
+          var a = La.buffer;
+          m = new Int8Array(a);
+          Ha = new Int16Array(a);
+          C = new Uint8Array(a);
+          new Uint16Array(a);
+          E = new Int32Array(a);
+          F = new Uint32Array(a);
+          Ia = new Float32Array(a);
+          Ja = new Float64Array(a);
+          G = new BigInt64Array(a);
+          new BigUint64Array(a);
+        }
+        function Ma(a) {
+          k.onAbort?.(a);
+          a = "Aborted(" + a + ")";
+          B(a);
+          Fa = true;
+          throw new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");
+        }
+        var Na;
+        async function Oa(a) {
+          if (!Ea) try {
+            var b = await Aa(a);
+            return new Uint8Array(b);
+          } catch {
           }
+          if (a == Na && Ea) a = new Uint8Array(Ea);
+          else if (Ba) a = Ba(a);
+          else throw "both async and sync fetching of the wasm failed";
+          return a;
         }
-      }
-    } catch {
-    }
-  }
-  identities.push(...await probeIdentities(os));
-  return {
-    installations: dedupeInstalls(installations),
-    identities: dedupeIdentities(identities)
-  };
-}
-function expandPath(p) {
-  let s = p;
-  s = s.replace(/\$XDG_CONFIG_HOME/g, process.env.XDG_CONFIG_HOME ?? `${homedir()}/.config`);
-  s = s.replace(/\$XDG_DATA_HOME/g, process.env.XDG_DATA_HOME ?? `${homedir()}/.local/share`);
-  s = s.replace(/\$HOME/g, homedir());
-  s = H(s);
-  return resolve2(s);
-}
-function binaryLookupDirs(os) {
-  const dirs = /* @__PURE__ */ new Set();
-  (process.env.PATH ?? "").split(":").forEach((d) => d && dirs.add(d));
-  const extra = os === "macos" ? [
-    "/opt/homebrew/bin",
-    "/usr/local/bin",
-    `${homedir()}/.bun/bin`,
-    `${homedir()}/.volta/bin`,
-    `${homedir()}/.cargo/bin`,
-    `${homedir()}/.local/bin`,
-    `${homedir()}/.asdf/shims`,
-    `${homedir()}/.mise/shims`,
-    `${homedir()}/.npm-global/bin`,
-    `${homedir()}/.yarn/bin`
-  ] : [
-    "/usr/local/bin",
-    "/usr/bin",
-    "/snap/bin",
-    "/var/lib/flatpak/exports/bin",
-    `${homedir()}/.local/bin`,
-    `${homedir()}/.bun/bin`,
-    `${homedir()}/.cargo/bin`,
-    `${homedir()}/.nvm`
-  ];
-  for (const d of extra) dirs.add(d);
-  return Array.from(dirs);
-}
-function classifyInstallMethod(binPath, os) {
-  if (binPath.includes("/homebrew/") || binPath.includes("/Cellar/")) return "homebrew";
-  if (binPath.includes("/.nvm/") || binPath.includes("/node_modules/")) return "npm_global";
-  if (binPath.includes("/.npm-global/")) return "npm_global";
-  if (binPath.includes("/.pnpm/") || binPath.includes("/.pnpm-global/")) return "pnpm_global";
-  if (binPath.includes("/.yarn/")) return "yarn_global";
-  if (binPath.includes("/.bun/")) return "bun_global";
-  if (binPath.includes("/.cargo/")) return "cargo_install";
-  if (binPath.startsWith("/Applications/") || binPath.includes(".app/Contents/")) return "app_bundle";
-  if (os === "linux" && binPath.startsWith("/snap/")) return "snap";
-  if (os === "linux" && binPath.includes("/flatpak/")) return "flatpak";
-  return "manual";
-}
-async function safeVersionProbe(binPath) {
+        async function Qa(a, b) {
+          try {
+            var c = await Oa(a);
+            return await WebAssembly.instantiate(c, b);
+          } catch (d) {
+            B(`failed to asynchronously prepare wasm: ${d}`), Ma(d);
+          }
+        }
+        async function Ra(a) {
+          var b = Na;
+          if (!Ea && !Ca(b) && !ca) try {
+            var c = fetch(b, { credentials: "same-origin" });
+            return await WebAssembly.instantiateStreaming(c, a);
+          } catch (d) {
+            B(`wasm streaming compile failed: ${d}`), B("falling back to ArrayBuffer instantiation");
+          }
+          return Qa(b, a);
+        }
+        class Sa {
+          name = "ExitStatus";
+          constructor(a) {
+            this.message = `Program terminated with exit(${a})`;
+            this.status = a;
+          }
+        }
+        var Ta = (a) => {
+          for (; 0 < a.length; ) a.shift()(k);
+        }, Ua = [], Va = [], Wa = () => {
+          var a = k.preRun.shift();
+          Va.push(a);
+        }, J = 0, Xa = null;
+        function r(a, b = "i8") {
+          b.endsWith("*") && (b = "*");
+          switch (b) {
+            case "i1":
+              return m[a];
+            case "i8":
+              return m[a];
+            case "i16":
+              return Ha[a >> 1];
+            case "i32":
+              return E[a >> 2];
+            case "i64":
+              return G[a >> 3];
+            case "float":
+              return Ia[a >> 2];
+            case "double":
+              return Ja[a >> 3];
+            case "*":
+              return F[a >> 2];
+            default:
+              Ma(`invalid type for getValue: ${b}`);
+          }
+        }
+        var Ya = true;
+        function qa(a) {
+          var b = "i32";
+          b.endsWith("*") && (b = "*");
+          switch (b) {
+            case "i1":
+              m[a] = 0;
+              break;
+            case "i8":
+              m[a] = 0;
+              break;
+            case "i16":
+              Ha[a >> 1] = 0;
+              break;
+            case "i32":
+              E[a >> 2] = 0;
+              break;
+            case "i64":
+              G[a >> 3] = BigInt(0);
+              break;
+            case "float":
+              Ia[a >> 2] = 0;
+              break;
+            case "double":
+              Ja[a >> 3] = 0;
+              break;
+            case "*":
+              F[a >> 2] = 0;
+              break;
+            default:
+              Ma(`invalid type for setValue: ${b}`);
+          }
+        }
+        var Za = new TextDecoder(), $a = (a, b, c, d) => {
+          c = b + c;
+          if (d) return c;
+          for (; a[b] && !(b >= c); ) ++b;
+          return b;
+        }, z = (a, b, c) => a ? Za.decode(C.subarray(a, $a(C, a, b, c))) : "", ab = (a, b) => {
+          for (var c = 0, d = a.length - 1; 0 <= d; d--) {
+            var e = a[d];
+            "." === e ? a.splice(d, 1) : ".." === e ? (a.splice(d, 1), c++) : c && (a.splice(d, 1), c--);
+          }
+          if (b) for (; c; c--) a.unshift("..");
+          return a;
+        }, ia = (a) => {
+          var b = "/" === a.charAt(0), c = "/" === a.slice(-1);
+          (a = ab(a.split("/").filter((d) => !!d), !b).join("/")) || b || (a = ".");
+          a && c && (a += "/");
+          return (b ? "/" : "") + a;
+        }, bb = (a) => {
+          var b = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(a).slice(1);
+          a = b[0];
+          b = b[1];
+          if (!a && !b) return ".";
+          b &&= b.slice(0, -1);
+          return a + b;
+        }, cb = (a) => a && a.match(/([^\/]+|\/)\/*$/)[1], db = () => {
+          if (ca) {
+            var a = __require("crypto");
+            return (b) => a.randomFillSync(b);
+          }
+          return (b) => crypto.getRandomValues(b);
+        }, eb = (a) => {
+          (eb = db())(a);
+        }, fb = (...a) => {
+          for (var b = "", c = false, d = a.length - 1; -1 <= d && !c; d--) {
+            c = 0 <= d ? a[d] : "/";
+            if ("string" != typeof c) throw new TypeError("Arguments to path.resolve must be strings");
+            if (!c) return "";
+            b = c + "/" + b;
+            c = "/" === c.charAt(0);
+          }
+          b = ab(b.split("/").filter((e) => !!e), !c).join("/");
+          return (c ? "/" : "") + b || ".";
+        }, gb = (a) => {
+          var b = $a(a, 0);
+          return Za.decode(a.buffer ? a.subarray(0, b) : new Uint8Array(a.slice(0, b)));
+        }, hb = [], ib = (a) => {
+          for (var b = 0, c = 0; c < a.length; ++c) {
+            var d = a.charCodeAt(c);
+            127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3;
+          }
+          return b;
+        }, M = (a, b, c, d) => {
+          if (!(0 < d)) return 0;
+          var e = c;
+          d = c + d - 1;
+          for (var g = 0; g < a.length; ++g) {
+            var h = a.codePointAt(g);
+            if (127 >= h) {
+              if (c >= d) break;
+              b[c++] = h;
+            } else if (2047 >= h) {
+              if (c + 1 >= d) break;
+              b[c++] = 192 | h >> 6;
+              b[c++] = 128 | h & 63;
+            } else if (65535 >= h) {
+              if (c + 2 >= d) break;
+              b[c++] = 224 | h >> 12;
+              b[c++] = 128 | h >> 6 & 63;
+              b[c++] = 128 | h & 63;
+            } else {
+              if (c + 3 >= d) break;
+              b[c++] = 240 | h >> 18;
+              b[c++] = 128 | h >> 12 & 63;
+              b[c++] = 128 | h >> 6 & 63;
+              b[c++] = 128 | h & 63;
+              g++;
+            }
+          }
+          b[c] = 0;
+          return c - e;
+        }, jb = [];
+        function kb(a, b) {
+          jb[a] = { input: [], output: [], eb: b };
+          mb(a, nb);
+        }
+        var nb = { open(a) {
+          var b = jb[a.node.rdev];
+          if (!b) throw new N(43);
+          a.tty = b;
+          a.seekable = false;
+        }, close(a) {
+          a.tty.eb.fsync(a.tty);
+        }, fsync(a) {
+          a.tty.eb.fsync(a.tty);
+        }, read(a, b, c, d) {
+          if (!a.tty || !a.tty.eb.Bb) throw new N(60);
+          for (var e = 0, g = 0; g < d; g++) {
+            try {
+              var h = a.tty.eb.Bb(a.tty);
+            } catch (q) {
+              throw new N(29);
+            }
+            if (void 0 === h && 0 === e) throw new N(6);
+            if (null === h || void 0 === h) break;
+            e++;
+            b[c + g] = h;
+          }
+          e && (a.node.atime = Date.now());
+          return e;
+        }, write(a, b, c, d) {
+          if (!a.tty || !a.tty.eb.ub) throw new N(60);
+          try {
+            for (var e = 0; e < d; e++) a.tty.eb.ub(a.tty, b[c + e]);
+          } catch (g) {
+            throw new N(29);
+          }
+          d && (a.node.mtime = a.node.ctime = Date.now());
+          return e;
+        } }, wb = { Bb() {
+          a: {
+            if (!hb.length) {
+              var a = null;
+              if (ca) {
+                var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
+                try {
+                  c = fs2.readSync(d, b, 0, 256);
+                } catch (e) {
+                  if (e.toString().includes("EOF")) c = 0;
+                  else throw e;
+                }
+                0 < c && (a = b.slice(0, c).toString("utf-8"));
+              } else globalThis.window?.prompt && (a = window.prompt("Input: "), null !== a && (a += "\n"));
+              if (!a) {
+                a = null;
+                break a;
+              }
+              b = Array(ib(a) + 1);
+              a = M(a, b, 0, b.length);
+              b.length = a;
+              hb = b;
+            }
+            a = hb.shift();
+          }
+          return a;
+        }, ub(a, b) {
+          null === b || 10 === b ? (Da(gb(a.output)), a.output = []) : 0 != b && a.output.push(b);
+        }, fsync(a) {
+          0 < a.output?.length && (Da(gb(a.output)), a.output = []);
+        }, hc() {
+          return { bc: 25856, dc: 5, ac: 191, cc: 35387, $b: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
+        }, ic() {
+          return 0;
+        }, jc() {
+          return [24, 80];
+        } }, xb = { ub(a, b) {
+          null === b || 10 === b ? (B(gb(a.output)), a.output = []) : 0 != b && a.output.push(b);
+        }, fsync(a) {
+          0 < a.output?.length && (B(gb(a.output)), a.output = []);
+        } }, O = { Wa: null, Xa() {
+          return O.createNode(null, "/", 16895, 0);
+        }, createNode(a, b, c, d) {
+          if (24576 === (c & 61440) || 4096 === (c & 61440)) throw new N(63);
+          O.Wa || (O.Wa = { dir: { node: { Ta: O.La.Ta, Ua: O.La.Ua, lookup: O.La.lookup, ib: O.La.ib, rename: O.La.rename, unlink: O.La.unlink, rmdir: O.La.rmdir, readdir: O.La.readdir, symlink: O.La.symlink }, stream: { Va: O.Ma.Va } }, file: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: { Va: O.Ma.Va, read: O.Ma.read, write: O.Ma.write, jb: O.Ma.jb, kb: O.Ma.kb } }, link: { node: { Ta: O.La.Ta, Ua: O.La.Ua, readlink: O.La.readlink }, stream: {} }, yb: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: yb } });
+          c = zb(a, b, c, d);
+          P(c.mode) ? (c.La = O.Wa.dir.node, c.Ma = O.Wa.dir.stream, c.Na = {}) : 32768 === (c.mode & 61440) ? (c.La = O.Wa.file.node, c.Ma = O.Wa.file.stream, c.Ra = 0, c.Na = null) : 40960 === (c.mode & 61440) ? (c.La = O.Wa.link.node, c.Ma = O.Wa.link.stream) : 8192 === (c.mode & 61440) && (c.La = O.Wa.yb.node, c.Ma = O.Wa.yb.stream);
+          c.atime = c.mtime = c.ctime = Date.now();
+          a && (a.Na[b] = c, a.atime = a.mtime = a.ctime = c.atime);
+          return c;
+        }, fc(a) {
+          return a.Na ? a.Na.subarray ? a.Na.subarray(0, a.Ra) : new Uint8Array(a.Na) : new Uint8Array(0);
+        }, La: {
+          Ta(a) {
+            var b = {};
+            b.dev = 8192 === (a.mode & 61440) ? a.id : 1;
+            b.ino = a.id;
+            b.mode = a.mode;
+            b.nlink = 1;
+            b.uid = 0;
+            b.gid = 0;
+            b.rdev = a.rdev;
+            P(a.mode) ? b.size = 4096 : 32768 === (a.mode & 61440) ? b.size = a.Ra : 40960 === (a.mode & 61440) ? b.size = a.link.length : b.size = 0;
+            b.atime = new Date(a.atime);
+            b.mtime = new Date(a.mtime);
+            b.ctime = new Date(a.ctime);
+            b.blksize = 4096;
+            b.blocks = Math.ceil(b.size / b.blksize);
+            return b;
+          },
+          Ua(a, b) {
+            for (var c of ["mode", "atime", "mtime", "ctime"]) null != b[c] && (a[c] = b[c]);
+            void 0 !== b.size && (b = b.size, a.Ra != b && (0 == b ? (a.Na = null, a.Ra = 0) : (c = a.Na, a.Na = new Uint8Array(b), c && a.Na.set(c.subarray(0, Math.min(b, a.Ra))), a.Ra = b)));
+          },
+          lookup() {
+            O.nb || (O.nb = new N(44), O.nb.stack = "<generic error, no stack>");
+            throw O.nb;
+          },
+          ib(a, b, c, d) {
+            return O.createNode(a, b, c, d);
+          },
+          rename(a, b, c) {
+            try {
+              var d = Q(b, c);
+            } catch (g) {
+            }
+            if (d) {
+              if (P(a.mode)) for (var e in d.Na) throw new N(55);
+              Ab(d);
+            }
+            delete a.parent.Na[a.name];
+            b.Na[c] = a;
+            a.name = c;
+            b.ctime = b.mtime = a.parent.ctime = a.parent.mtime = Date.now();
+          },
+          unlink(a, b) {
+            delete a.Na[b];
+            a.ctime = a.mtime = Date.now();
+          },
+          rmdir(a, b) {
+            var c = Q(a, b), d;
+            for (d in c.Na) throw new N(55);
+            delete a.Na[b];
+            a.ctime = a.mtime = Date.now();
+          },
+          readdir(a) {
+            return [".", "..", ...Object.keys(a.Na)];
+          },
+          symlink(a, b, c) {
+            a = O.createNode(a, b, 41471, 0);
+            a.link = c;
+            return a;
+          },
+          readlink(a) {
+            if (40960 !== (a.mode & 61440)) throw new N(28);
+            return a.link;
+          }
+        }, Ma: { read(a, b, c, d, e) {
+          var g = a.node.Na;
+          if (e >= a.node.Ra) return 0;
+          a = Math.min(a.node.Ra - e, d);
+          if (8 < a && g.subarray) b.set(g.subarray(e, e + a), c);
+          else for (d = 0; d < a; d++) b[c + d] = g[e + d];
+          return a;
+        }, write(a, b, c, d, e, g) {
+          b.buffer === m.buffer && (g = false);
+          if (!d) return 0;
+          a = a.node;
+          a.mtime = a.ctime = Date.now();
+          if (b.subarray && (!a.Na || a.Na.subarray)) {
+            if (g) return a.Na = b.subarray(c, c + d), a.Ra = d;
+            if (0 === a.Ra && 0 === e) return a.Na = b.slice(c, c + d), a.Ra = d;
+            if (e + d <= a.Ra) return a.Na.set(b.subarray(c, c + d), e), d;
+          }
+          g = e + d;
+          var h = a.Na ? a.Na.length : 0;
+          h >= g || (g = Math.max(g, h * (1048576 > h ? 2 : 1.125) >>> 0), 0 != h && (g = Math.max(g, 256)), h = a.Na, a.Na = new Uint8Array(g), 0 < a.Ra && a.Na.set(h.subarray(0, a.Ra), 0));
+          if (a.Na.subarray && b.subarray) a.Na.set(b.subarray(c, c + d), e);
+          else for (g = 0; g < d; g++) a.Na[e + g] = b[c + g];
+          a.Ra = Math.max(a.Ra, e + d);
+          return d;
+        }, Va(a, b, c) {
+          1 === c ? b += a.position : 2 === c && 32768 === (a.node.mode & 61440) && (b += a.node.Ra);
+          if (0 > b) throw new N(28);
+          return b;
+        }, jb(a, b, c, d, e) {
+          if (32768 !== (a.node.mode & 61440)) throw new N(43);
+          a = a.node.Na;
+          if (e & 2 || !a || a.buffer !== m.buffer) {
+            e = true;
+            d = 65536 * Math.ceil(b / 65536);
+            var g = Bb(65536, d);
+            g && C.fill(0, g, g + d);
+            d = g;
+            if (!d) throw new N(48);
+            if (a) {
+              if (0 < c || c + b < a.length) a.subarray ? a = a.subarray(c, c + b) : a = Array.prototype.slice.call(a, c, c + b);
+              m.set(a, d);
+            }
+          } else e = false, d = a.byteOffset;
+          return { Xb: d, Eb: e };
+        }, kb(a, b, c, d) {
+          O.Ma.write(a, b, 0, d, c, false);
+          return 0;
+        } } }, ja = (a, b) => {
+          var c = 0;
+          a && (c |= 365);
+          b && (c |= 146);
+          return c;
+        }, Cb = null, Db = {}, Eb = [], Fb = 1, R = null, Gb = false, Hb = true, N = class {
+          name = "ErrnoError";
+          constructor(a) {
+            this.Pa = a;
+          }
+        }, Ib = class {
+          hb = {};
+          node = null;
+          get flags() {
+            return this.hb.flags;
+          }
+          set flags(a) {
+            this.hb.flags = a;
+          }
+          get position() {
+            return this.hb.position;
+          }
+          set position(a) {
+            this.hb.position = a;
+          }
+        }, Jb = class {
+          La = {};
+          Ma = {};
+          bb = null;
+          constructor(a, b, c, d) {
+            a ||= this;
+            this.parent = a;
+            this.Xa = a.Xa;
+            this.id = Fb++;
+            this.name = b;
+            this.mode = c;
+            this.rdev = d;
+            this.atime = this.mtime = this.ctime = Date.now();
+          }
+          get read() {
+            return 365 === (this.mode & 365);
+          }
+          set read(a) {
+            a ? this.mode |= 365 : this.mode &= -366;
+          }
+          get write() {
+            return 146 === (this.mode & 146);
+          }
+          set write(a) {
+            a ? this.mode |= 146 : this.mode &= -147;
+          }
+        };
+        function S(a, b = {}) {
+          if (!a) throw new N(44);
+          b.pb ?? (b.pb = true);
+          "/" === a.charAt(0) || (a = "//" + a);
+          var c = 0;
+          a: for (; 40 > c; c++) {
+            a = a.split("/").filter((q) => !!q);
+            for (var d = Cb, e = "/", g = 0; g < a.length; g++) {
+              var h = g === a.length - 1;
+              if (h && b.parent) break;
+              if ("." !== a[g]) if (".." === a[g]) if (e = bb(e), d === d.parent) {
+                a = e + "/" + a.slice(g + 1).join("/");
+                c--;
+                continue a;
+              } else d = d.parent;
+              else {
+                e = ia(e + "/" + a[g]);
+                try {
+                  d = Q(d, a[g]);
+                } catch (q) {
+                  if (44 === q?.Pa && h && b.Wb) return { path: e };
+                  throw q;
+                }
+                !d.bb || h && !b.pb || (d = d.bb.root);
+                if (40960 === (d.mode & 61440) && (!h || b.ab)) {
+                  if (!d.La.readlink) throw new N(52);
+                  d = d.La.readlink(d);
+                  "/" === d.charAt(0) || (d = bb(e) + "/" + d);
+                  a = d + "/" + a.slice(g + 1).join("/");
+                  continue a;
+                }
+              }
+            }
+            return { path: e, node: d };
+          }
+          throw new N(32);
+        }
+        function ha(a) {
+          for (var b; ; ) {
+            if (a === a.parent) return a = a.Xa.Db, b ? "/" !== a[a.length - 1] ? `${a}/${b}` : a + b : a;
+            b = b ? `${a.name}/${b}` : a.name;
+            a = a.parent;
+          }
+        }
+        function Kb(a, b) {
+          for (var c = 0, d = 0; d < b.length; d++) c = (c << 5) - c + b.charCodeAt(d) | 0;
+          return (a + c >>> 0) % R.length;
+        }
+        function Ab(a) {
+          var b = Kb(a.parent.id, a.name);
+          if (R[b] === a) R[b] = a.cb;
+          else for (b = R[b]; b; ) {
+            if (b.cb === a) {
+              b.cb = a.cb;
+              break;
+            }
+            b = b.cb;
+          }
+        }
+        function Q(a, b) {
+          var c = P(a.mode) ? (c = Lb(a, "x")) ? c : a.La.lookup ? 0 : 2 : 54;
+          if (c) throw new N(c);
+          for (c = R[Kb(a.id, b)]; c; c = c.cb) {
+            var d = c.name;
+            if (c.parent.id === a.id && d === b) return c;
+          }
+          return a.La.lookup(a, b);
+        }
+        function zb(a, b, c, d) {
+          a = new Jb(a, b, c, d);
+          b = Kb(a.parent.id, a.name);
+          a.cb = R[b];
+          return R[b] = a;
+        }
+        function P(a) {
+          return 16384 === (a & 61440);
+        }
+        function Lb(a, b) {
+          return Hb ? 0 : b.includes("r") && !(a.mode & 292) || b.includes("w") && !(a.mode & 146) || b.includes("x") && !(a.mode & 73) ? 2 : 0;
+        }
+        function Mb(a, b) {
+          if (!P(a.mode)) return 54;
+          try {
+            return Q(a, b), 20;
+          } catch (c) {
+          }
+          return Lb(a, "wx");
+        }
+        function Nb(a, b, c) {
+          try {
+            var d = Q(a, b);
+          } catch (e) {
+            return e.Pa;
+          }
+          if (a = Lb(a, "wx")) return a;
+          if (c) {
+            if (!P(d.mode)) return 54;
+            if (d === d.parent || "/" === ha(d)) return 10;
+          } else if (P(d.mode)) return 31;
+          return 0;
+        }
+        function Ob(a) {
+          if (!a) throw new N(63);
+          return a;
+        }
+        function T(a) {
+          a = Eb[a];
+          if (!a) throw new N(8);
+          return a;
+        }
+        function Pb(a, b = -1) {
+          a = Object.assign(new Ib(), a);
+          if (-1 == b) a: {
+            for (b = 0; 4096 >= b; b++) if (!Eb[b]) break a;
+            throw new N(33);
+          }
+          a.fd = b;
+          return Eb[b] = a;
+        }
+        function Qb(a, b = -1) {
+          a = Pb(a, b);
+          a.Ma?.ec?.(a);
+          return a;
+        }
+        function Rb(a, b, c) {
+          var d = a?.Ma.Ua;
+          a = d ? a : b;
+          d ??= b.La.Ua;
+          Ob(d);
+          d(a, c);
+        }
+        var yb = { open(a) {
+          a.Ma = Db[a.node.rdev].Ma;
+          a.Ma.open?.(a);
+        }, Va() {
+          throw new N(70);
+        } };
+        function mb(a, b) {
+          Db[a] = { Ma: b };
+        }
+        function Sb(a, b) {
+          var c = "/" === b;
+          if (c && Cb) throw new N(10);
+          if (!c && b) {
+            var d = S(b, { pb: false });
+            b = d.path;
+            d = d.node;
+            if (d.bb) throw new N(10);
+            if (!P(d.mode)) throw new N(54);
+          }
+          b = { type: a, kc: {}, Db: b, Vb: [] };
+          a = a.Xa(b);
+          a.Xa = b;
+          b.root = a;
+          c ? Cb = a : d && (d.bb = b, d.Xa && d.Xa.Vb.push(b));
+        }
+        function Tb(a, b, c) {
+          var d = S(a, { parent: true }).node;
+          a = cb(a);
+          if (!a) throw new N(28);
+          if ("." === a || ".." === a) throw new N(20);
+          var e = Mb(d, a);
+          if (e) throw new N(e);
+          if (!d.La.ib) throw new N(63);
+          return d.La.ib(d, a, b, c);
+        }
+        function ka(a, b = 438) {
+          return Tb(a, b & 4095 | 32768, 0);
+        }
+        function U(a, b = 511) {
+          return Tb(a, b & 1023 | 16384, 0);
+        }
+        function Ub(a, b, c) {
+          "undefined" == typeof c && (c = b, b = 438);
+          Tb(a, b | 8192, c);
+        }
+        function Vb(a, b) {
+          if (!fb(a)) throw new N(44);
+          var c = S(b, { parent: true }).node;
+          if (!c) throw new N(44);
+          b = cb(b);
+          var d = Mb(c, b);
+          if (d) throw new N(d);
+          if (!c.La.symlink) throw new N(63);
+          c.La.symlink(c, b, a);
+        }
+        function Wb(a) {
+          var b = S(a, { parent: true }).node;
+          a = cb(a);
+          var c = Q(b, a), d = Nb(b, a, true);
+          if (d) throw new N(d);
+          if (!b.La.rmdir) throw new N(63);
+          if (c.bb) throw new N(10);
+          b.La.rmdir(b, a);
+          Ab(c);
+        }
+        function ua(a) {
+          var b = S(a, { parent: true }).node;
+          if (!b) throw new N(44);
+          a = cb(a);
+          var c = Q(b, a), d = Nb(b, a, false);
+          if (d) throw new N(d);
+          if (!b.La.unlink) throw new N(63);
+          if (c.bb) throw new N(10);
+          b.La.unlink(b, a);
+          Ab(c);
+        }
+        function Xb(a, b) {
+          a = S(a, { ab: !b }).node;
+          return Ob(a.La.Ta)(a);
+        }
+        function Yb(a, b, c, d) {
+          Rb(a, b, { mode: c & 4095 | b.mode & -4096, ctime: Date.now(), Lb: d });
+        }
+        function la(a, b) {
+          a = "string" == typeof a ? S(a, { ab: true }).node : a;
+          Yb(null, a, b);
+        }
+        function Zb(a, b, c) {
+          if (P(b.mode)) throw new N(31);
+          if (32768 !== (b.mode & 61440)) throw new N(28);
+          var d = Lb(b, "w");
+          if (d) throw new N(d);
+          Rb(a, b, { size: c, timestamp: Date.now() });
+        }
+        function ma(a, b, c = 438) {
+          if ("" === a) throw new N(44);
+          if ("string" == typeof b) {
+            var d = { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }[b];
+            if ("undefined" == typeof d) throw Error(`Unknown file open mode: ${b}`);
+            b = d;
+          }
+          c = b & 64 ? c & 4095 | 32768 : 0;
+          if ("object" == typeof a) d = a;
+          else {
+            var e = a.endsWith("/");
+            var g = S(a, { ab: !(b & 131072), Wb: true });
+            d = g.node;
+            a = g.path;
+          }
+          g = false;
+          if (b & 64) if (d) {
+            if (b & 128) throw new N(20);
+          } else {
+            if (e) throw new N(31);
+            d = Tb(a, c | 511, 0);
+            g = true;
+          }
+          if (!d) throw new N(44);
+          8192 === (d.mode & 61440) && (b &= -513);
+          if (b & 65536 && !P(d.mode)) throw new N(54);
+          if (!g && (d ? 40960 === (d.mode & 61440) ? e = 32 : (e = ["r", "w", "rw"][b & 3], b & 512 && (e += "w"), e = P(d.mode) && ("r" !== e || b & 576) ? 31 : Lb(d, e)) : e = 44, e)) throw new N(e);
+          b & 512 && !g && (e = d, e = "string" == typeof e ? S(e, { ab: true }).node : e, Zb(null, e, 0));
+          b = Pb({ node: d, path: ha(d), flags: b & -131713, seekable: true, position: 0, Ma: d.Ma, Yb: [], error: false });
+          b.Ma.open && b.Ma.open(b);
+          g && la(d, c & 511);
+          return b;
+        }
+        function oa(a) {
+          if (null === a.fd) throw new N(8);
+          a.rb && (a.rb = null);
+          try {
+            a.Ma.close && a.Ma.close(a);
+          } catch (b) {
+            throw b;
+          } finally {
+            Eb[a.fd] = null;
+          }
+          a.fd = null;
+        }
+        function $b(a, b, c) {
+          if (null === a.fd) throw new N(8);
+          if (!a.seekable || !a.Ma.Va) throw new N(70);
+          if (0 != c && 1 != c && 2 != c) throw new N(28);
+          a.position = a.Ma.Va(a, b, c);
+          a.Yb = [];
+        }
+        function ac(a, b, c, d, e) {
+          if (0 > d || 0 > e) throw new N(28);
+          if (null === a.fd) throw new N(8);
+          if (1 === (a.flags & 2097155)) throw new N(8);
+          if (P(a.node.mode)) throw new N(31);
+          if (!a.Ma.read) throw new N(28);
+          var g = "undefined" != typeof e;
+          if (!g) e = a.position;
+          else if (!a.seekable) throw new N(70);
+          b = a.Ma.read(a, b, c, d, e);
+          g || (a.position += b);
+          return b;
+        }
+        function na(a, b, c, d, e) {
+          if (0 > d || 0 > e) throw new N(28);
+          if (null === a.fd) throw new N(8);
+          if (0 === (a.flags & 2097155)) throw new N(8);
+          if (P(a.node.mode)) throw new N(31);
+          if (!a.Ma.write) throw new N(28);
+          a.seekable && a.flags & 1024 && $b(a, 0, 2);
+          var g = "undefined" != typeof e;
+          if (!g) e = a.position;
+          else if (!a.seekable) throw new N(70);
+          b = a.Ma.write(a, b, c, d, e, void 0);
+          g || (a.position += b);
+          return b;
+        }
+        function ta(a) {
+          var b = b || 0;
+          var c = "binary";
+          "utf8" !== c && "binary" !== c && Ma(`Invalid encoding type "${c}"`);
+          b = ma(a, b);
+          a = Xb(a).size;
+          var d = new Uint8Array(a);
+          ac(b, d, 0, a, 0);
+          "utf8" === c && (d = gb(d));
+          oa(b);
+          return d;
+        }
+        function W(a, b, c) {
+          a = ia("/dev/" + a);
+          var d = ja(!!b, !!c);
+          W.Cb ?? (W.Cb = 64);
+          var e = W.Cb++ << 8 | 0;
+          mb(e, { open(g) {
+            g.seekable = false;
+          }, close() {
+            c?.buffer?.length && c(10);
+          }, read(g, h, q, w) {
+            for (var t = 0, x = 0; x < w; x++) {
+              try {
+                var D = b();
+              } catch (pb) {
+                throw new N(29);
+              }
+              if (void 0 === D && 0 === t) throw new N(6);
+              if (null === D || void 0 === D) break;
+              t++;
+              h[q + x] = D;
+            }
+            t && (g.node.atime = Date.now());
+            return t;
+          }, write(g, h, q, w) {
+            for (var t = 0; t < w; t++) try {
+              c(h[q + t]);
+            } catch (x) {
+              throw new N(29);
+            }
+            w && (g.node.mtime = g.node.ctime = Date.now());
+            return t;
+          } });
+          Ub(a, d, e);
+        }
+        var X = {};
+        function Y(a, b, c) {
+          if ("/" === b.charAt(0)) return b;
+          a = -100 === a ? "/" : T(a).path;
+          if (0 == b.length) {
+            if (!c) throw new N(44);
+            return a;
+          }
+          return a + "/" + b;
+        }
+        function kc(a, b) {
+          F[a >> 2] = b.dev;
+          F[a + 4 >> 2] = b.mode;
+          F[a + 8 >> 2] = b.nlink;
+          F[a + 12 >> 2] = b.uid;
+          F[a + 16 >> 2] = b.gid;
+          F[a + 20 >> 2] = b.rdev;
+          G[a + 24 >> 3] = BigInt(b.size);
+          E[a + 32 >> 2] = 4096;
+          E[a + 36 >> 2] = b.blocks;
+          var c = b.atime.getTime(), d = b.mtime.getTime(), e = b.ctime.getTime();
+          G[a + 40 >> 3] = BigInt(Math.floor(c / 1e3));
+          F[a + 48 >> 2] = c % 1e3 * 1e6;
+          G[a + 56 >> 3] = BigInt(Math.floor(d / 1e3));
+          F[a + 64 >> 2] = d % 1e3 * 1e6;
+          G[a + 72 >> 3] = BigInt(Math.floor(e / 1e3));
+          F[a + 80 >> 2] = e % 1e3 * 1e6;
+          G[a + 88 >> 3] = BigInt(b.ino);
+          return 0;
+        }
+        var Cc = void 0, Ec = () => {
+          var a = E[+Cc >> 2];
+          Cc += 4;
+          return a;
+        }, Fc = 0, Gc = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Hc = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Ic = {}, Jc = (a) => {
+          Ga = a;
+          Ya || 0 < Fc || (k.onExit?.(a), Fa = true);
+          xa(a, new Sa(a));
+        }, Kc = (a) => {
+          if (!Fa) try {
+            a();
+          } catch (b) {
+            b instanceof Sa || "unwind" == b || xa(1, b);
+          } finally {
+            if (!(Ya || 0 < Fc)) try {
+              Ga = a = Ga, Jc(a);
+            } catch (b) {
+              b instanceof Sa || "unwind" == b || xa(1, b);
+            }
+          }
+        }, Lc = {}, Nc = () => {
+          if (!Mc) {
+            var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: (globalThis.navigator?.language ?? "C").replace("-", "_") + ".UTF-8", _: wa || "./this.program" }, b;
+            for (b in Lc) void 0 === Lc[b] ? delete a[b] : a[b] = Lc[b];
+            var c = [];
+            for (b in a) c.push(`${b}=${a[b]}`);
+            Mc = c;
+          }
+          return Mc;
+        }, Mc, Oc = (a, b, c, d) => {
+          var e = { string: (t) => {
+            var x = 0;
+            if (null !== t && void 0 !== t && 0 !== t) {
+              x = ib(t) + 1;
+              var D = y(x);
+              M(t, C, D, x);
+              x = D;
+            }
+            return x;
+          }, array: (t) => {
+            var x = y(t.length);
+            m.set(t, x);
+            return x;
+          } };
+          a = k["_" + a];
+          var g = [], h = 0;
+          if (d) for (var q = 0; q < d.length; q++) {
+            var w = e[c[q]];
+            w ? (0 === h && (h = pa()), g[q] = w(d[q])) : g[q] = d[q];
+          }
+          c = a(...g);
+          return c = (function(t) {
+            0 !== h && ra(h);
+            return "string" === b ? z(t) : "boolean" === b ? !!t : t;
+          })(c);
+        }, fa = (a) => {
+          var b = ib(a) + 1, c = da(b);
+          c && M(a, C, c, b);
+          return c;
+        }, Pc, Qc = [], A = (a) => {
+          Pc.delete(Z.get(a));
+          Z.set(a, null);
+          Qc.push(a);
+        }, Rc = (a) => {
+          const b = a.length;
+          return [b % 128 | 128, b >> 7, ...a];
+        }, Sc = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 }, Tc = (a) => Rc(Array.from(a, (b) => Sc[b])), va = (a, b) => {
+          if (!Pc) {
+            Pc = /* @__PURE__ */ new WeakMap();
+            var c = Z.length;
+            if (Pc) for (var d = 0; d < 0 + c; d++) {
+              var e = Z.get(d);
+              e && Pc.set(e, d);
+            }
+          }
+          if (c = Pc.get(a) || 0) return c;
+          c = Qc.length ? Qc.pop() : Z.grow(1);
+          try {
+            Z.set(c, a);
+          } catch (g) {
+            if (!(g instanceof TypeError)) throw g;
+            b = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...Rc([1, 96, ...Tc(b.slice(1)), ...Tc("v" === b[0] ? "" : b[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+            b = new WebAssembly.Module(b);
+            b = new WebAssembly.Instance(b, { e: { f: a } }).exports.f;
+            Z.set(c, b);
+          }
+          Pc.set(a, c);
+          return c;
+        };
+        R = Array(4096);
+        Sb(O, "/");
+        U("/tmp");
+        U("/home");
+        U("/home/web_user");
+        (function() {
+          U("/dev");
+          mb(259, { read: () => 0, write: (d, e, g, h) => h, Va: () => 0 });
+          Ub("/dev/null", 259);
+          kb(1280, wb);
+          kb(1536, xb);
+          Ub("/dev/tty", 1280);
+          Ub("/dev/tty1", 1536);
+          var a = new Uint8Array(1024), b = 0, c = () => {
+            0 === b && (eb(a), b = a.byteLength);
+            return a[--b];
+          };
+          W("random", c);
+          W("urandom", c);
+          U("/dev/shm");
+          U("/dev/shm/tmp");
+        })();
+        (function() {
+          U("/proc");
+          var a = U("/proc/self");
+          U("/proc/self/fd");
+          Sb({ Xa() {
+            var b = zb(a, "fd", 16895, 73);
+            b.Ma = { Va: O.Ma.Va };
+            b.La = { lookup(c, d) {
+              c = +d;
+              var e = T(c);
+              c = { parent: null, Xa: { Db: "fake" }, La: { readlink: () => e.path }, id: c + 1 };
+              return c.parent = c;
+            }, readdir() {
+              return Array.from(Eb.entries()).filter(([, c]) => c).map(([c]) => c.toString());
+            } };
+            return b;
+          } }, "/proc/self/fd");
+        })();
+        k.noExitRuntime && (Ya = k.noExitRuntime);
+        k.print && (Da = k.print);
+        k.printErr && (B = k.printErr);
+        k.wasmBinary && (Ea = k.wasmBinary);
+        k.thisProgram && (wa = k.thisProgram);
+        if (k.preInit) for ("function" == typeof k.preInit && (k.preInit = [k.preInit]); 0 < k.preInit.length; ) k.preInit.shift()();
+        k.stackSave = () => pa();
+        k.stackRestore = (a) => ra(a);
+        k.stackAlloc = (a) => y(a);
+        k.cwrap = (a, b, c, d) => {
+          var e = !c || c.every((g) => "number" === g || "boolean" === g);
+          return "string" !== b && e && !d ? k["_" + a] : (...g) => Oc(a, b, c, g);
+        };
+        k.addFunction = va;
+        k.removeFunction = A;
+        k.UTF8ToString = z;
+        k.stringToNewUTF8 = fa;
+        k.writeArrayToMemory = (a, b) => {
+          m.set(a, b);
+        };
+        var da, ea, Bb, Uc, ra, y, pa, La, Z, Vc = {
+          a: (a, b, c, d) => Ma(`Assertion failed: ${z(a)}, at: ` + [b ? z(b) : "unknown filename", c, d ? z(d) : "unknown function"]),
+          i: function(a, b) {
+            try {
+              return a = z(a), la(a, b), 0;
+            } catch (c) {
+              if ("undefined" == typeof X || "ErrnoError" !== c.name) throw c;
+              return -c.Pa;
+            }
+          },
+          L: function(a, b, c) {
+            try {
+              b = z(b);
+              b = Y(a, b);
+              if (c & -8) return -28;
+              var d = S(b, { ab: true }).node;
+              if (!d) return -44;
+              a = "";
+              c & 4 && (a += "r");
+              c & 2 && (a += "w");
+              c & 1 && (a += "x");
+              return a && Lb(d, a) ? -2 : 0;
+            } catch (e) {
+              if ("undefined" == typeof X || "ErrnoError" !== e.name) throw e;
+              return -e.Pa;
+            }
+          },
+          j: function(a, b) {
+            try {
+              var c = T(a);
+              Yb(c, c.node, b, false);
+              return 0;
+            } catch (d) {
+              if ("undefined" == typeof X || "ErrnoError" !== d.name) throw d;
+              return -d.Pa;
+            }
+          },
+          h: function(a) {
+            try {
+              var b = T(a);
+              Rb(b, b.node, { timestamp: Date.now(), Lb: false });
+              return 0;
+            } catch (c) {
+              if ("undefined" == typeof X || "ErrnoError" !== c.name) throw c;
+              return -c.Pa;
+            }
+          },
+          b: function(a, b, c) {
+            Cc = c;
+            try {
+              var d = T(a);
+              switch (b) {
+                case 0:
+                  var e = Ec();
+                  if (0 > e) break;
+                  for (; Eb[e]; ) e++;
+                  return Qb(d, e).fd;
+                case 1:
+                case 2:
+                  return 0;
+                case 3:
+                  return d.flags;
+                case 4:
+                  return e = Ec(), d.flags |= e, 0;
+                case 12:
+                  return e = Ec(), Ha[e + 0 >> 1] = 2, 0;
+                case 13:
+                case 14:
+                  return 0;
+              }
+              return -28;
+            } catch (g) {
+              if ("undefined" == typeof X || "ErrnoError" !== g.name) throw g;
+              return -g.Pa;
+            }
+          },
+          g: function(a, b) {
+            try {
+              var c = T(a), d = c.node, e = c.Ma.Ta;
+              a = e ? c : d;
+              e ??= d.La.Ta;
+              Ob(e);
+              var g = e(a);
+              return kc(b, g);
+            } catch (h) {
+              if ("undefined" == typeof X || "ErrnoError" !== h.name) throw h;
+              return -h.Pa;
+            }
+          },
+          H: function(a, b) {
+            b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+            try {
+              if (isNaN(b)) return -61;
+              var c = T(a);
+              if (0 > b || 0 === (c.flags & 2097155)) throw new N(28);
+              Zb(c, c.node, b);
+              return 0;
+            } catch (d) {
+              if ("undefined" == typeof X || "ErrnoError" !== d.name) throw d;
+              return -d.Pa;
+            }
+          },
+          G: function(a, b) {
+            try {
+              if (0 === b) return -28;
+              var c = ib("/") + 1;
+              if (b < c) return -68;
+              M("/", C, a, b);
+              return c;
+            } catch (d) {
+              if ("undefined" == typeof X || "ErrnoError" !== d.name) throw d;
+              return -d.Pa;
+            }
+          },
+          K: function(a, b) {
+            try {
+              return a = z(a), kc(b, Xb(a, true));
+            } catch (c) {
+              if ("undefined" == typeof X || "ErrnoError" !== c.name) throw c;
+              return -c.Pa;
+            }
+          },
+          C: function(a, b, c) {
+            try {
+              return b = z(b), b = Y(a, b), U(b, c), 0;
+            } catch (d) {
+              if ("undefined" == typeof X || "ErrnoError" !== d.name) throw d;
+              return -d.Pa;
+            }
+          },
+          J: function(a, b, c, d) {
+            try {
+              b = z(b);
+              var e = d & 256;
+              b = Y(a, b, d & 4096);
+              return kc(c, e ? Xb(b, true) : Xb(b));
+            } catch (g) {
+              if ("undefined" == typeof X || "ErrnoError" !== g.name) throw g;
+              return -g.Pa;
+            }
+          },
+          x: function(a, b, c, d) {
+            Cc = d;
+            try {
+              b = z(b);
+              b = Y(a, b);
+              var e = d ? Ec() : 0;
+              return ma(b, c, e).fd;
+            } catch (g) {
+              if ("undefined" == typeof X || "ErrnoError" !== g.name) throw g;
+              return -g.Pa;
+            }
+          },
+          v: function(a, b, c, d) {
+            try {
+              b = z(b);
+              b = Y(a, b);
+              if (0 >= d) return -28;
+              var e = S(b).node;
+              if (!e) throw new N(44);
+              if (!e.La.readlink) throw new N(28);
+              var g = e.La.readlink(e);
+              var h = Math.min(d, ib(g)), q = m[c + h];
+              M(
+                g,
+                C,
+                c,
+                d + 1
+              );
+              m[c + h] = q;
+              return h;
+            } catch (w) {
+              if ("undefined" == typeof X || "ErrnoError" !== w.name) throw w;
+              return -w.Pa;
+            }
+          },
+          u: function(a) {
+            try {
+              return a = z(a), Wb(a), 0;
+            } catch (b) {
+              if ("undefined" == typeof X || "ErrnoError" !== b.name) throw b;
+              return -b.Pa;
+            }
+          },
+          f: function(a, b) {
+            try {
+              return a = z(a), kc(b, Xb(a));
+            } catch (c) {
+              if ("undefined" == typeof X || "ErrnoError" !== c.name) throw c;
+              return -c.Pa;
+            }
+          },
+          r: function(a, b, c) {
+            try {
+              b = z(b);
+              b = Y(a, b);
+              if (c) if (512 === c) Wb(b);
+              else return -28;
+              else ua(b);
+              return 0;
+            } catch (d) {
+              if ("undefined" == typeof X || "ErrnoError" !== d.name) throw d;
+              return -d.Pa;
+            }
+          },
+          q: function(a, b, c) {
+            try {
+              b = z(b);
+              b = Y(a, b, true);
+              var d = Date.now(), e, g;
+              if (c) {
+                var h = F[c >> 2] + 4294967296 * E[c + 4 >> 2], q = E[c + 8 >> 2];
+                1073741823 == q ? e = d : 1073741822 == q ? e = null : e = 1e3 * h + q / 1e6;
+                c += 16;
+                h = F[c >> 2] + 4294967296 * E[c + 4 >> 2];
+                q = E[c + 8 >> 2];
+                1073741823 == q ? g = d : 1073741822 == q ? g = null : g = 1e3 * h + q / 1e6;
+              } else g = e = d;
+              if (null !== (g ?? e)) {
+                a = e;
+                var w = S(b, { ab: true }).node;
+                Ob(w.La.Ua)(w, { atime: a, mtime: g });
+              }
+              return 0;
+            } catch (t) {
+              if ("undefined" == typeof X || "ErrnoError" !== t.name) throw t;
+              return -t.Pa;
+            }
+          },
+          m: () => Ma(""),
+          l: () => {
+            Ya = false;
+            Fc = 0;
+          },
+          A: function(a, b) {
+            a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);
+            a = new Date(1e3 * a);
+            E[b >> 2] = a.getSeconds();
+            E[b + 4 >> 2] = a.getMinutes();
+            E[b + 8 >> 2] = a.getHours();
+            E[b + 12 >> 2] = a.getDate();
+            E[b + 16 >> 2] = a.getMonth();
+            E[b + 20 >> 2] = a.getFullYear() - 1900;
+            E[b + 24 >> 2] = a.getDay();
+            var c = a.getFullYear();
+            E[b + 28 >> 2] = (0 !== c % 4 || 0 === c % 100 && 0 !== c % 400 ? Hc : Gc)[a.getMonth()] + a.getDate() - 1 | 0;
+            E[b + 36 >> 2] = -(60 * a.getTimezoneOffset());
+            c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset();
+            var d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();
+            E[b + 32 >> 2] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0;
+          },
+          y: function(a, b, c, d, e, g, h) {
+            e = -9007199254740992 > e || 9007199254740992 < e ? NaN : Number(e);
+            try {
+              var q = T(d);
+              if (0 !== (b & 2) && 0 === (c & 2) && 2 !== (q.flags & 2097155)) throw new N(2);
+              if (1 === (q.flags & 2097155)) throw new N(2);
+              if (!q.Ma.jb) throw new N(43);
+              if (!a) throw new N(28);
+              var w = q.Ma.jb(q, a, e, b, c);
+              var t = w.Xb;
+              E[g >> 2] = w.Eb;
+              F[h >> 2] = t;
+              return 0;
+            } catch (x) {
+              if ("undefined" == typeof X || "ErrnoError" !== x.name) throw x;
+              return -x.Pa;
+            }
+          },
+          z: function(a, b, c, d, e, g) {
+            g = -9007199254740992 > g || 9007199254740992 < g ? NaN : Number(g);
+            try {
+              var h = T(e);
+              if (c & 2) {
+                c = g;
+                if (32768 !== (h.node.mode & 61440)) throw new N(43);
+                if (!(d & 2)) {
+                  var q = C.slice(a, a + b);
+                  h.Ma.kb && h.Ma.kb(h, q, c, b, d);
+                }
+              }
+            } catch (w) {
+              if ("undefined" == typeof X || "ErrnoError" !== w.name) throw w;
+              return -w.Pa;
+            }
+          },
+          n: (a, b) => {
+            Ic[a] && (clearTimeout(Ic[a].id), delete Ic[a]);
+            if (!b) return 0;
+            var c = setTimeout(() => {
+              delete Ic[a];
+              Kc(() => Uc(a, performance.now()));
+            }, b);
+            Ic[a] = { id: c, lc: b };
+            return 0;
+          },
+          B: (a, b, c, d) => {
+            var e = (/* @__PURE__ */ new Date()).getFullYear(), g = new Date(e, 0, 1).getTimezoneOffset();
+            e = new Date(e, 6, 1).getTimezoneOffset();
+            F[a >> 2] = 60 * Math.max(g, e);
+            E[b >> 2] = Number(g != e);
+            b = (h) => {
+              var q = Math.abs(h);
+              return `UTC${0 <= h ? "-" : "+"}${String(Math.floor(q / 60)).padStart(2, "0")}${String(q % 60).padStart(2, "0")}`;
+            };
+            a = b(g);
+            b = b(e);
+            e < g ? (M(a, C, c, 17), M(b, C, d, 17)) : (M(a, C, d, 17), M(b, C, c, 17));
+          },
+          d: () => Date.now(),
+          s: () => 2147483648,
+          c: () => performance.now(),
+          o: (a) => {
+            var b = C.length;
+            a >>>= 0;
+            if (2147483648 < a) return false;
+            for (var c = 1; 4 >= c; c *= 2) {
+              var d = b * (1 + 0.2 / c);
+              d = Math.min(d, a + 100663296);
+              a: {
+                d = (Math.min(2147483648, 65536 * Math.ceil(Math.max(
+                  a,
+                  d
+                ) / 65536)) - La.buffer.byteLength + 65535) / 65536 | 0;
+                try {
+                  La.grow(d);
+                  Ka();
+                  var e = 1;
+                  break a;
+                } catch (g) {
+                }
+                e = void 0;
+              }
+              if (e) return true;
+            }
+            return false;
+          },
+          E: (a, b) => {
+            var c = 0, d = 0, e;
+            for (e of Nc()) {
+              var g = b + c;
+              F[a + d >> 2] = g;
+              c += M(e, C, g, Infinity) + 1;
+              d += 4;
+            }
+            return 0;
+          },
+          F: (a, b) => {
+            var c = Nc();
+            F[a >> 2] = c.length;
+            a = 0;
+            for (var d of c) a += ib(d) + 1;
+            F[b >> 2] = a;
+            return 0;
+          },
+          e: function(a) {
+            try {
+              var b = T(a);
+              oa(b);
+              return 0;
+            } catch (c) {
+              if ("undefined" == typeof X || "ErrnoError" !== c.name) throw c;
+              return c.Pa;
+            }
+          },
+          p: function(a, b) {
+            try {
+              var c = T(a);
+              m[b] = c.tty ? 2 : P(c.mode) ? 3 : 40960 === (c.mode & 61440) ? 7 : 4;
+              Ha[b + 2 >> 1] = 0;
+              G[b + 8 >> 3] = BigInt(0);
+              G[b + 16 >> 3] = BigInt(0);
+              return 0;
+            } catch (d) {
+              if ("undefined" == typeof X || "ErrnoError" !== d.name) throw d;
+              return d.Pa;
+            }
+          },
+          w: function(a, b, c, d) {
+            try {
+              a: {
+                var e = T(a);
+                a = b;
+                for (var g, h = b = 0; h < c; h++) {
+                  var q = F[a >> 2], w = F[a + 4 >> 2];
+                  a += 8;
+                  var t = ac(e, m, q, w, g);
+                  if (0 > t) {
+                    var x = -1;
+                    break a;
+                  }
+                  b += t;
+                  if (t < w) break;
+                  "undefined" != typeof g && (g += t);
+                }
+                x = b;
+              }
+              F[d >> 2] = x;
+              return 0;
+            } catch (D) {
+              if ("undefined" == typeof X || "ErrnoError" !== D.name) throw D;
+              return D.Pa;
+            }
+          },
+          D: function(a, b, c, d) {
+            b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+            try {
+              if (isNaN(b)) return 61;
+              var e = T(a);
+              $b(e, b, c);
+              G[d >> 3] = BigInt(e.position);
+              e.rb && 0 === b && 0 === c && (e.rb = null);
+              return 0;
+            } catch (g) {
+              if ("undefined" == typeof X || "ErrnoError" !== g.name) throw g;
+              return g.Pa;
+            }
+          },
+          I: function(a) {
+            try {
+              var b = T(a);
+              return b.Ma?.fsync?.(b);
+            } catch (c) {
+              if ("undefined" == typeof X || "ErrnoError" !== c.name) throw c;
+              return c.Pa;
+            }
+          },
+          t: function(a, b, c, d) {
+            try {
+              a: {
+                var e = T(a);
+                a = b;
+                for (var g, h = b = 0; h < c; h++) {
+                  var q = F[a >> 2], w = F[a + 4 >> 2];
+                  a += 8;
+                  var t = na(e, m, q, w, g);
+                  if (0 > t) {
+                    var x = -1;
+                    break a;
+                  }
+                  b += t;
+                  if (t < w) break;
+                  "undefined" != typeof g && (g += t);
+                }
+                x = b;
+              }
+              F[d >> 2] = x;
+              return 0;
+            } catch (D) {
+              if ("undefined" == typeof X || "ErrnoError" !== D.name) throw D;
+              return D.Pa;
+            }
+          },
+          k: Jc
+        };
+        function Wc() {
+          function a() {
+            k.calledRun = true;
+            if (!Fa) {
+              if (!k.noFSInit && !Gb) {
+                var b, c;
+                Gb = true;
+                b ??= k.stdin;
+                c ??= k.stdout;
+                d ??= k.stderr;
+                b ? W("stdin", b) : Vb("/dev/tty", "/dev/stdin");
+                c ? W("stdout", null, c) : Vb("/dev/tty", "/dev/stdout");
+                d ? W("stderr", null, d) : Vb("/dev/tty1", "/dev/stderr");
+                ma("/dev/stdin", 0);
+                ma("/dev/stdout", 1);
+                ma("/dev/stderr", 1);
+              }
+              Xc.N();
+              Hb = false;
+              k.onRuntimeInitialized?.();
+              if (k.postRun) for ("function" == typeof k.postRun && (k.postRun = [k.postRun]); k.postRun.length; ) {
+                var d = k.postRun.shift();
+                Ua.push(d);
+              }
+              Ta(Ua);
+            }
+          }
+          if (0 < J) Xa = Wc;
+          else {
+            if (k.preRun) for ("function" == typeof k.preRun && (k.preRun = [k.preRun]); k.preRun.length; ) Wa();
+            Ta(Va);
+            0 < J ? Xa = Wc : k.setStatus ? (k.setStatus("Running..."), setTimeout(() => {
+              setTimeout(() => k.setStatus(""), 1);
+              a();
+            }, 1)) : a();
+          }
+        }
+        var Xc;
+        (async function() {
+          function a(c) {
+            c = Xc = c.exports;
+            k._sqlite3_free = c.P;
+            k._sqlite3_value_text = c.Q;
+            k._sqlite3_prepare_v2 = c.R;
+            k._sqlite3_step = c.S;
+            k._sqlite3_reset = c.T;
+            k._sqlite3_exec = c.U;
+            k._sqlite3_finalize = c.V;
+            k._sqlite3_column_name = c.W;
+            k._sqlite3_column_text = c.X;
+            k._sqlite3_column_type = c.Y;
+            k._sqlite3_errmsg = c.Z;
+            k._sqlite3_clear_bindings = c._;
+            k._sqlite3_value_blob = c.$;
+            k._sqlite3_value_bytes = c.aa;
+            k._sqlite3_value_double = c.ba;
+            k._sqlite3_value_int = c.ca;
+            k._sqlite3_value_type = c.da;
+            k._sqlite3_result_blob = c.ea;
+            k._sqlite3_result_double = c.fa;
+            k._sqlite3_result_error = c.ga;
+            k._sqlite3_result_int = c.ha;
+            k._sqlite3_result_int64 = c.ia;
+            k._sqlite3_result_null = c.ja;
+            k._sqlite3_result_text = c.ka;
+            k._sqlite3_aggregate_context = c.la;
+            k._sqlite3_column_count = c.ma;
+            k._sqlite3_data_count = c.na;
+            k._sqlite3_column_blob = c.oa;
+            k._sqlite3_column_bytes = c.pa;
+            k._sqlite3_column_double = c.qa;
+            k._sqlite3_bind_blob = c.ra;
+            k._sqlite3_bind_double = c.sa;
+            k._sqlite3_bind_int = c.ta;
+            k._sqlite3_bind_text = c.ua;
+            k._sqlite3_bind_parameter_index = c.va;
+            k._sqlite3_sql = c.wa;
+            k._sqlite3_normalized_sql = c.xa;
+            k._sqlite3_changes = c.ya;
+            k._sqlite3_close_v2 = c.za;
+            k._sqlite3_create_function_v2 = c.Aa;
+            k._sqlite3_update_hook = c.Ba;
+            k._sqlite3_open = c.Ca;
+            da = k._malloc = c.Da;
+            ea = k._free = c.Ea;
+            k._RegisterExtensionFunctions = c.Fa;
+            Bb = c.Ga;
+            Uc = c.Ha;
+            ra = c.Ia;
+            y = c.Ja;
+            pa = c.Ka;
+            La = c.M;
+            Z = c.O;
+            Ka();
+            J--;
+            k.monitorRunDependencies?.(J);
+            0 == J && Xa && (c = Xa, Xa = null, c());
+            return Xc;
+          }
+          J++;
+          k.monitorRunDependencies?.(J);
+          var b = { a: Vc };
+          if (k.instantiateWasm) return new Promise((c) => {
+            k.instantiateWasm(b, (d, e) => {
+              c(a(d, e));
+            });
+          });
+          Na ??= k.locateFile ? k.locateFile("sql-wasm.wasm", za) : za + "sql-wasm.wasm";
+          return a((await Ra(b)).instance);
+        })();
+        Wc();
+        return Module;
+      });
+      return initSqlJsPromise;
+    };
+    if (typeof exports === "object" && typeof module === "object") {
+      module.exports = initSqlJs2;
+      module.exports.default = initSqlJs2;
+    } else if (typeof define === "function" && define["amd"]) {
+      define([], function() {
+        return initSqlJs2;
+      });
+    } else if (typeof exports === "object") {
+      exports["Module"] = initSqlJs2;
+    }
+  }
+});
+
+// ../../packages/parsers/src/cursor/index.ts
+import { readFileSync } from "fs";
+var import_sql;
+var init_cursor = __esm({
+  "../../packages/parsers/src/cursor/index.ts"() {
+    "use strict";
+    import_sql = __toESM(require_sql_wasm(), 1);
+    init_src();
+  }
+});
+
+// ../../packages/parsers/src/discovery/index.ts
+import { execFile as execFile2, execSync } from "child_process";
+import { existsSync as existsSync2, statSync } from "fs";
+import { homedir, platform } from "os";
+import { join, resolve as resolve2 } from "path";
+import { promisify as promisify2 } from "util";
+async function discover(options = {}) {
+  const os = platform() === "darwin" ? "macos" : "linux";
+  const skip = new Set(options.skip ?? []);
+  const installations = [];
+  const identities = [];
+  for (const spec of SOURCES) {
+    const candidates = /* @__PURE__ */ new Set();
+    for (const raw of spec.dataDirs[os] ?? []) candidates.add(expandPath(raw));
+    for (const env of spec.dataDirEnv ?? []) {
+      const v = process.env[env];
+      if (v) candidates.add(v);
+    }
+    for (const extra of options.extraDataDirs?.[spec.tool] ?? []) candidates.add(expandPath(extra));
+    for (const p of candidates) {
+      if (existsSync2(p) && statSync(p).isDirectory()) {
+        installations.push({
+          tool: spec.tool,
+          install_method: "manual",
+          binary_path: null,
+          data_dir: p,
+          version: null,
+          detected_via: ["known_path"]
+        });
+      }
+    }
+  }
+  if (!skip.has("binaryWalk")) {
+    const binDirs = binaryLookupDirs(os);
+    for (const spec of SOURCES) {
+      for (const bin of spec.binaries ?? []) {
+        for (const dir of binDirs) {
+          const p = join(dir, bin);
+          if (existsSync2(p)) {
+            const version = await safeVersionProbe(p);
+            installations.push({
+              tool: spec.tool,
+              install_method: classifyInstallMethod(p, os),
+              binary_path: p,
+              data_dir: null,
+              version,
+              detected_via: ["binary_walk"]
+            });
+          }
+        }
+      }
+    }
+  }
+  if (!skip.has("appRegistry") && os === "macos") {
+    try {
+      const apps = await macosListApps();
+      for (const spec of SOURCES) {
+        for (const bid of spec.bundleIds ?? []) {
+          const hit = apps.find((a) => a.bundleId === bid);
+          if (hit) {
+            installations.push({
+              tool: spec.tool,
+              install_method: "app_bundle",
+              binary_path: hit.path,
+              data_dir: null,
+              version: hit.version,
+              detected_via: ["app_registry"]
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  identities.push(...await probeIdentities(os));
+  return {
+    installations: dedupeInstalls(installations),
+    identities: dedupeIdentities(identities)
+  };
+}
+function expandPath(p) {
+  let s = p;
+  s = s.replace(/\$XDG_CONFIG_HOME/g, process.env.XDG_CONFIG_HOME ?? `${homedir()}/.config`);
+  s = s.replace(/\$XDG_DATA_HOME/g, process.env.XDG_DATA_HOME ?? `${homedir()}/.local/share`);
+  s = s.replace(/\$HOME/g, homedir());
+  s = H(s);
+  return resolve2(s);
+}
+function binaryLookupDirs(os) {
+  const dirs = /* @__PURE__ */ new Set();
+  (process.env.PATH ?? "").split(":").forEach((d) => d && dirs.add(d));
+  const extra = os === "macos" ? [
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    `${homedir()}/.bun/bin`,
+    `${homedir()}/.volta/bin`,
+    `${homedir()}/.cargo/bin`,
+    `${homedir()}/.local/bin`,
+    `${homedir()}/.asdf/shims`,
+    `${homedir()}/.mise/shims`,
+    `${homedir()}/.npm-global/bin`,
+    `${homedir()}/.yarn/bin`
+  ] : [
+    "/usr/local/bin",
+    "/usr/bin",
+    "/snap/bin",
+    "/var/lib/flatpak/exports/bin",
+    `${homedir()}/.local/bin`,
+    `${homedir()}/.bun/bin`,
+    `${homedir()}/.cargo/bin`,
+    `${homedir()}/.nvm`
+  ];
+  for (const d of extra) dirs.add(d);
+  return Array.from(dirs);
+}
+function classifyInstallMethod(binPath, os) {
+  if (binPath.includes("/homebrew/") || binPath.includes("/Cellar/")) return "homebrew";
+  if (binPath.includes("/.nvm/") || binPath.includes("/node_modules/")) return "npm_global";
+  if (binPath.includes("/.npm-global/")) return "npm_global";
+  if (binPath.includes("/.pnpm/") || binPath.includes("/.pnpm-global/")) return "pnpm_global";
+  if (binPath.includes("/.yarn/")) return "yarn_global";
+  if (binPath.includes("/.bun/")) return "bun_global";
+  if (binPath.includes("/.cargo/")) return "cargo_install";
+  if (binPath.startsWith("/Applications/") || binPath.includes(".app/Contents/")) return "app_bundle";
+  if (os === "linux" && binPath.startsWith("/snap/")) return "snap";
+  if (os === "linux" && binPath.includes("/flatpak/")) return "flatpak";
+  return "manual";
+}
+async function safeVersionProbe(binPath) {
   try {
     const { stdout } = await pexec2(binPath, ["--version"], { timeout: 1500 });
     return stdout.trim().split(/\s+/).pop() ?? null;
@@ -4948,7 +7216,7 @@ async function macosListApps() {
 }
 async function probeIdentities(os) {
   const ids = [];
-  const fs = await import("fs");
+  const fs2 = await import("fs");
   if (os === "macos") {
     try {
       const out = execSync(
@@ -4977,7 +7245,7 @@ async function probeIdentities(os) {
   ]) {
     if (!existsSync2(candidate)) continue;
     try {
-      const data = await fs.promises.readFile(candidate, "utf8");
+      const data = await fs2.promises.readFile(candidate, "utf8");
       const obj = JSON.parse(data);
       const jwt = obj.tokens?.id_token;
       let email = null;
@@ -5017,7 +7285,7 @@ async function probeIdentities(os) {
   ]) {
     if (!existsSync2(candidate)) continue;
     try {
-      const data = await fs.promises.readFile(candidate, "utf8");
+      const data = await fs2.promises.readFile(candidate, "utf8");
       const obj = JSON.parse(data);
       const email = obj.email ?? obj.token?.email;
       if (email) {
@@ -5038,7 +7306,7 @@ async function probeIdentities(os) {
   ]) {
     if (!existsSync2(candidate)) continue;
     try {
-      const data = await fs.promises.readFile(candidate, "utf8");
+      const data = await fs2.promises.readFile(candidate, "utf8");
       const obj = JSON.parse(data);
       for (const k of Object.keys(obj)) {
         if (k.startsWith("cursorAuth") && typeof obj[k] === "string") {
@@ -5188,6 +7456,147 @@ var init_src2 = __esm({
   }
 });
 
+// ../../packages/companion-core/src/config/index.ts
+function expBackoff(attempt) {
+  const i = Math.min(Math.max(attempt, 0), BACKOFF_MS.length - 1);
+  return BACKOFF_MS[i];
+}
+var BACKOFF_MS, BACKSTOP_SCAN_MS;
+var init_config = __esm({
+  "../../packages/companion-core/src/config/index.ts"() {
+    "use strict";
+    BACKOFF_MS = [1e3, 2500, 5e3, 1e4, 2e4, 6e4];
+    BACKSTOP_SCAN_MS = 5 * 6e4;
+  }
+});
+
+// ../../packages/companion-core/src/http/index.ts
+function classifyStatus(status2, attempt) {
+  if (status2 >= 200 && status2 < 300) return { type: "commit" };
+  if (status2 === 400 || status2 === 422) return { type: "drop", reason: `http_${status2}` };
+  if (status2 === 401 || status2 === 403) return { type: "reauth" };
+  if (status2 === 408 || status2 === 429 || status2 >= 500) {
+    return { type: "backoff", delayMs: expBackoff(attempt) };
+  }
+  return { type: "drop", reason: `http_${status2}` };
+}
+function sleep(ms) {
+  return new Promise((r) => {
+    setTimeout(r, ms);
+  });
+}
+var IngestClient;
+var init_http = __esm({
+  "../../packages/companion-core/src/http/index.ts"() {
+    "use strict";
+    init_config();
+    IngestClient = class {
+      constructor(opts) {
+        this.opts = opts;
+        this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+        this.maxAttempts = opts.maxAttempts ?? 3;
+      }
+      opts;
+      fetchImpl;
+      maxAttempts;
+      async upload(batch) {
+        const url = `${this.opts.apiUrl.replace(/\/+$/, "")}/v1/ingest`;
+        for (let attempt = 0; attempt < this.maxAttempts; attempt++) {
+          const token = await this.opts.auth.getToken();
+          if (!token) {
+            const reauthed = await this.opts.auth.onInvalidToken();
+            if (!reauthed) return { kind: "drop", reason: "no_token" };
+            continue;
+          }
+          let res;
+          try {
+            res = await this.fetchImpl(url, {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`
+              },
+              body: JSON.stringify(batch)
+            });
+          } catch (err) {
+            this.opts.logger.warn("ingest fetch failed", { err: String(err), attempt });
+            await sleep(expBackoff(attempt));
+            continue;
+          }
+          const decision = classifyStatus(res.status, attempt);
+          if (decision.type === "commit") {
+            const body = await res.json().catch(() => ({}));
+            return { kind: "commit", response: body };
+          }
+          if (decision.type === "drop") {
+            const text = await res.text().catch(() => "");
+            this.opts.logger.error("ingest dropped", {
+              status: res.status,
+              reason: decision.reason,
+              body: text.slice(0, 500)
+            });
+            return { kind: "drop", reason: decision.reason };
+          }
+          if (decision.type === "reauth") {
+            const ok = await this.opts.auth.onInvalidToken();
+            if (!ok) return { kind: "drop", reason: "reauth_failed" };
+            continue;
+          }
+          this.opts.logger.warn("ingest backoff", {
+            status: res.status,
+            delay_ms: decision.delayMs,
+            attempt
+          });
+          await sleep(decision.delayMs);
+        }
+        return { kind: "drop", reason: "max_attempts_exceeded" };
+      }
+    };
+  }
+});
+
+// ../../packages/companion-core/src/logger.ts
+function defaultLevel() {
+  const env = globalThis.process?.env ?? {};
+  const raw = (env.LOG_LEVEL ?? "").toLowerCase();
+  if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error") return raw;
+  return env.NODE_ENV === "production" ? "info" : "debug";
+}
+function consoleLogger(opts = {}) {
+  const scope = opts.scope ?? "main";
+  const level = opts.level ?? defaultLevel();
+  const threshold = LEVEL_RANK[level];
+  const emit = (lvl, msg, fields) => {
+    if (LEVEL_RANK[lvl] < threshold) return;
+    const prefix = `[modelstat:${scope}]`;
+    const args = fields !== void 0 ? [prefix, msg, fields] : [prefix, msg];
+    const fn = lvl === "warn" ? "warn" : lvl === "error" ? "error" : "log";
+    console[fn](...args);
+  };
+  return {
+    debug: (msg, fields) => emit("debug", msg, fields),
+    info: (msg, fields) => emit("info", msg, fields),
+    warn: (msg, fields) => emit("warn", msg, fields),
+    error: (msg, fields) => emit("error", msg, fields),
+    child: (childScope) => consoleLogger({ scope: `${scope}:${childScope}`, level })
+  };
+}
+function createLogger(scope, opts = {}) {
+  return consoleLogger({ scope, ...opts });
+}
+var LEVEL_RANK;
+var init_logger = __esm({
+  "../../packages/companion-core/src/logger.ts"() {
+    "use strict";
+    LEVEL_RANK = {
+      debug: 10,
+      info: 20,
+      warn: 30,
+      error: 40
+    };
+  }
+});
+
 // src/config.ts
 import { config as loadDotenv } from "dotenv";
 import Conf from "conf";
@@ -5195,14 +7604,8 @@ import { existsSync as existsSync3 } from "fs";
 import { hostname } from "os";
 import { dirname as dirname2, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
-function machineId() {
-  return `dev-${hostname()}`;
-}
-function defaultUserEmail() {
-  return process.env.AGENT_USER_EMAIL ?? state.userEmail ?? "aram@dev.local";
-}
 var here, DEFAULT_API_URL, LEGACY_LOCALHOST_API, store, state;
-var init_config = __esm({
+var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
     here = dirname2(fileURLToPath(import.meta.url));
@@ -5321,45 +7724,13 @@ async function fetchDeviceMe(secret) {
   }
   return await res.body.json();
 }
-async function startDeviceCode() {
-  const res = await request(`${state.apiUrl}/v1/auth/device_code`, {
+async function rotateDeviceSecret(currentSecret) {
+  const res = await request(`${state.apiUrl}/v1/devices/me/rotate-secret`, {
     method: "POST",
-    headers: { "content-type": "application/json" },
-    // Fastify's JSON body parser rejects an empty body when the
-    // content-type is application/json, so send `{}` explicitly.
-    body: "{}"
+    headers: { authorization: `Bearer ${currentSecret}` }
   });
   if (res.statusCode >= 300) {
-    throw new Error(`device_code start failed: ${res.statusCode} ${await res.body.text()}`);
-  }
-  return await res.body.json();
-}
-async function pollDeviceCode(deviceCode) {
-  const res = await request(`${state.apiUrl}/v1/auth/device_code/poll`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ device_code: deviceCode })
-  });
-  if (res.statusCode === 202) return { status: "pending" };
-  if (res.statusCode === 410) throw new Error("device_code expired or already claimed");
-  if (res.statusCode >= 300) {
-    throw new Error(`device_code poll failed: ${res.statusCode} ${await res.body.text()}`);
-  }
-  const body = await res.body.json();
-  return { status: "approved", ...body };
-}
-async function enrollDevice(input) {
-  const bearer = state.bearer;
-  const headers = { "content-type": "application/json" };
-  if (bearer) headers["authorization"] = `Bearer ${bearer}`;
-  const res = await request(`${state.apiUrl}/v1/devices/register`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(input)
-  });
-  if (res.statusCode >= 300) {
-    const body = await res.body.text();
-    throw new Error(`enrollDevice failed: ${res.statusCode} ${body}`);
+    throw new Error(`rotate-secret failed: ${res.statusCode} ${await res.body.text()}`);
   }
   return await res.body.json();
 }
@@ -5376,118 +7747,436 @@ async function reportDiscovery(report) {
     throw new Error(`reportDiscovery failed: ${res.statusCode} ${body}`);
   }
 }
-async function uploadBatch(batch) {
-  const bearer = state.bearer;
-  if (!bearer) throw new Error("agent not enrolled");
-  const res = await request(`${state.apiUrl}/v1/ingest`, {
-    method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${bearer}` },
-    body: JSON.stringify(batch)
+async function fetchDeviceViewByClaim(claimCode) {
+  const res = await request(`${state.apiUrl}/v1/d/${encodeURIComponent(claimCode)}`, {
+    method: "GET"
+  });
+  if (res.statusCode === 404) return null;
+  if (res.statusCode >= 300) {
+    throw new Error(`device-view failed: ${res.statusCode} ${await res.body.text()}`);
+  }
+  return await res.body.json();
+}
+async function fetchDeviceViewJobsByClaim(claimCode) {
+  const res = await request(
+    `${state.apiUrl}/v1/d/${encodeURIComponent(claimCode)}/jobs`,
+    { method: "GET" }
+  );
+  if (res.statusCode === 404) return null;
+  if (res.statusCode >= 300) {
+    throw new Error(`device-view jobs failed: ${res.statusCode} ${await res.body.text()}`);
+  }
+  return await res.body.json();
+}
+async function fetchDeviceViewLedgerByClaim(claimCode) {
+  const res = await request(
+    `${state.apiUrl}/v1/d/${encodeURIComponent(claimCode)}/ledger`,
+    { method: "GET" }
+  );
+  if (res.statusCode === 404) return null;
+  if (res.statusCode >= 300) {
+    throw new Error(`device-view ledger failed: ${res.statusCode} ${await res.body.text()}`);
+  }
+  return await res.body.json();
+}
+function ingestClient() {
+  if (_ingest) return _ingest;
+  const logger = createLogger("agent.ingest");
+  _ingest = new IngestClient({
+    apiUrl: state.apiUrl,
+    auth: {
+      getToken: async () => state.bearer,
+      onInvalidToken: async () => {
+        const current = state.bearer;
+        if (!current) return false;
+        try {
+          await rotateDeviceSecret(current);
+          return !!state.bearer;
+        } catch {
+          return false;
+        }
+      }
+    },
+    logger
   });
-  const body = await res.body.text();
-  if (res.statusCode >= 300) {
-    throw new Error(`upload failed: ${res.statusCode} ${body}`);
+  return _ingest;
+}
+async function uploadBatch(batch) {
+  const result = await ingestClient().upload(batch);
+  if (result.kind !== "commit") {
+    throw new Error(`upload failed: ${result.reason}`);
   }
-  return JSON.parse(body);
+  return {
+    accepted: result.response.accepted,
+    new_sessions: result.response.new_sessions,
+    updated_sessions: result.response.updated_sessions,
+    batch_id: result.response.batch_id
+  };
 }
+var _ingest;
 var init_api = __esm({
   "src/api.ts"() {
+    "use strict";
+    init_http();
+    init_logger();
+    init_config2();
+    _ingest = null;
+  }
+});
+
+// ../../packages/companion-core/src/contracts/index.ts
+var init_contracts = __esm({
+  "../../packages/companion-core/src/contracts/index.ts"() {
+    "use strict";
+    init_schemas();
+    init_enums();
+  }
+});
+
+// ../../packages/companion-core/src/ids.ts
+var init_ids2 = __esm({
+  "../../packages/companion-core/src/ids.ts"() {
+    "use strict";
+    init_ids();
+  }
+});
+
+// ../../packages/companion-core/src/queue/index.ts
+var init_queue = __esm({
+  "../../packages/companion-core/src/queue/index.ts"() {
     "use strict";
     init_config();
+    init_ids2();
+  }
+});
+
+// ../../packages/companion-core/src/pipeline/prompts.ts
+var OLLAMA_CHAT_MODEL, OLLAMA_EMBED_MODEL, SUMMARISER_SYSTEM_PROMPT, SUMMARISER_MAX_TOKENS, SUMMARISER_TEMPERATURE, QWEN_CHARS_PER_TOKEN;
+var init_prompts = __esm({
+  "../../packages/companion-core/src/pipeline/prompts.ts"() {
+    "use strict";
+    OLLAMA_CHAT_MODEL = "qwen3:0.6b";
+    OLLAMA_EMBED_MODEL = "bge-small-en-v1.5";
+    SUMMARISER_SYSTEM_PROMPT = "You summarise an AI coding session in ONE sentence, \u2264 240 characters. Focus on what the human was trying to accomplish. No quotes, no PII, no code literals, no file paths. Reply with only the sentence.";
+    SUMMARISER_MAX_TOKENS = 120;
+    SUMMARISER_TEMPERATURE = 0.2;
+    QWEN_CHARS_PER_TOKEN = 3.3;
   }
 });
 
-// src/segment.ts
-function summariseSessionEvents(session) {
-  const totalTokens = {
+// ../../packages/companion-core/src/pipeline/index.ts
+async function buildSegmentsForSession(events, adapters2) {
+  if (events.length === 0) return [];
+  const bySession = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const arr = bySession.get(ev.session_id) ?? [];
+    arr.push(ev);
+    bySession.set(ev.session_id, arr);
+  }
+  const out = [];
+  for (const [sessionId, evs] of bySession) {
+    const segs = await buildForOneSession(sessionId, evs, adapters2);
+    out.push(...segs);
+  }
+  return out;
+}
+async function buildForOneSession(sessionId, events, adapters2) {
+  const sorted = [...events].sort((a, b) => a.ts.localeCompare(b.ts));
+  const turnSurfaces = sorted.map((e) => turnSurface(e));
+  const turnEmbeddings = [];
+  for (const s of turnSurfaces) {
+    turnEmbeddings.push(s.length > 0 ? await adapters2.embed(s) : []);
+  }
+  const boundaries = [];
+  let runStart = 0;
+  let runStartMs = Date.parse(sorted[0].ts);
+  for (let i = 1; i < sorted.length; i++) {
+    const prev2 = sorted[i - 1];
+    const cur = sorted[i];
+    const gap = Date.parse(cur.ts) - Date.parse(prev2.ts);
+    const runMs = Date.parse(cur.ts) - runStartMs;
+    const turnsInRun = i - runStart;
+    let split = false;
+    if (gap >= SEGMENT_TIME_GAP_MS) split = true;
+    else if (turnsInRun >= SEGMENT_MAX_TURNS) split = true;
+    else if (runMs >= SEGMENT_MAX_DURATION_MS) split = true;
+    else if (turnEmbeddings[i - 1].length > 0 && turnEmbeddings[i].length > 0 && cosineDistance(turnEmbeddings[i - 1], turnEmbeddings[i]) > SEGMENT_TOPIC_THRESHOLD) {
+      split = true;
+    }
+    if (split) {
+      boundaries.push(i);
+      runStart = i;
+      runStartMs = Date.parse(cur.ts);
+    }
+  }
+  boundaries.push(sorted.length);
+  const slices = [];
+  let prev = 0;
+  for (const b of boundaries) {
+    slices.push(sorted.slice(prev, b));
+    prev = b;
+  }
+  const merged = [];
+  for (const slice of slices) {
+    const last = merged[merged.length - 1];
+    if (slice.length === 1 && last) {
+      last.push(...slice);
+    } else {
+      merged.push(slice);
+    }
+  }
+  const segments = [];
+  for (const slice of merged) {
+    const seg = await summariseSlice(sessionId, slice, adapters2);
+    if (seg) segments.push(seg);
+  }
+  return segments;
+}
+async function summariseSlice(sessionId, slice, adapters2) {
+  if (slice.length === 0) return null;
+  const first = slice[0];
+  const last = slice[slice.length - 1];
+  const startedAtMs = Date.parse(first.ts);
+  const endedAtMs = Date.parse(last.ts);
+  const tokens = {
     input: 0,
     output: 0,
     cache_creation: 0,
     cache_read: 0,
     reasoning: 0
   };
-  for (const e of session.events) {
-    if (!e.tokens) continue;
-    totalTokens.input += e.tokens.input;
-    totalTokens.output += e.tokens.output;
-    totalTokens.cache_creation += e.tokens.cache_creation;
-    totalTokens.cache_read += e.tokens.cache_read;
-    totalTokens.reasoning += e.tokens.reasoning;
-  }
-  const firstTyped = session.events.find((e) => e.kind !== "user_message");
-  const anyWithGit = session.events.find((e) => e.git?.remote_slug);
-  const anyWithCwd = session.events.find((e) => e.cwd);
-  const tool = firstTyped?.tool ?? session.events[0]?.tool ?? "unknown";
-  const provider = firstTyped?.provider ?? session.events[0]?.provider ?? "unknown";
-  const model = firstTyped?.model ?? session.events[0]?.model ?? null;
-  const branch = anyWithGit?.git?.branch ?? null;
-  const slug = anyWithGit?.git?.remote_slug ?? null;
-  const hints = [];
-  if (slug) {
-    hints.push({ root_key: "projects", name: slug, confidence: 1 });
-  }
-  hints.push({ root_key: "providers", name: provider, confidence: 1 });
-  if (model) hints.push({ root_key: "models", name: model, confidence: 1 });
-  hints.push({ root_key: "tools", name: tool, confidence: 1 });
-  const env = inferEnvironment(branch);
-  if (env) hints.push({ root_key: "environments", name: env, confidence: 0.7 });
-  const work = inferWorkType(branch);
-  if (work) hints.push({ root_key: "work_types", name: work, confidence: 0.6 });
-  const segment = {
-    idx: 0,
-    started_at: session.events[0]?.ts ?? null,
-    ended_at: session.events[session.events.length - 1]?.ts ?? null,
-    tokens: totalTokens,
-    turn_range: null,
-    goal: null,
-    feature: null,
-    work_type_hint: work,
-    domain_keywords: [],
-    taxonomy_hints: hints
-  };
-  return {
-    goal: null,
-    feature_hint: null,
-    work_type_hint: work,
-    domain_keywords: [],
-    segments: [segment],
-    redaction_report: {
-      secrets_found: 0,
-      emails_redacted: 0,
-      paths_redacted_absolute: 0
+  for (const ev of slice) {
+    if (!ev.tokens) continue;
+    tokens.input += ev.tokens.input;
+    tokens.output += ev.tokens.output;
+    tokens.cache_creation += ev.tokens.cache_creation;
+    tokens.cache_read += ev.tokens.cache_read;
+    tokens.reasoning += ev.tokens.reasoning;
+  }
+  const promptFacts = [
+    first.git?.remote_slug ? `repo ${first.git.remote_slug}` : null,
+    first.git?.branch ? `branch ${first.git.branch}` : null,
+    `${slice.length} turns on ${first.tool}`,
+    first.files_touched?.length ? `files touched: ${first.files_touched.slice(0, 5).join(", ")}` : null,
+    Object.keys(first.tool_calls ?? {}).length ? `tool calls: ${Object.keys(first.tool_calls).slice(0, 5).join(", ")}` : null
+  ].filter(Boolean).join("; ");
+  const prompt = `Session context: ${promptFacts || "generic coding session"}.
+Write one sentence describing what the human was doing.`;
+  let rawAbstract;
+  try {
+    rawAbstract = await adapters2.summarize({ prompt, maxTokens: 80 });
+  } catch {
+    rawAbstract = promptFacts || `${first.tool} session with ${slice.length} turns`;
+  }
+  const redacted = redact(rawAbstract);
+  const tags = [
+    { root_key: "tools", name: first.tool, confidence: 1 },
+    { root_key: "providers", name: first.provider, confidence: 1 }
+  ];
+  if (first.model) tags.push({ root_key: "models", name: first.model, confidence: 1 });
+  if (first.git?.remote_slug) {
+    tags.push({ root_key: "projects", name: first.git.remote_slug, confidence: 1 });
+  }
+  if (first.git?.branch) {
+    const env = inferEnvironment(first.git.branch);
+    if (env) tags.push({ root_key: "environments", name: env, confidence: 0.7 });
+  }
+  const components = /* @__PURE__ */ new Set();
+  for (const ev of slice) {
+    for (const f of ev.files_touched ?? []) {
+      const seg = f.split("/").slice(0, 2).join("/");
+      if (seg) components.add(seg);
     }
+  }
+  for (const c of [...components].slice(0, 8)) {
+    tags.push({ root_key: "components", name: c, confidence: 0.6 });
+  }
+  let segmentEmbedding;
+  try {
+    const embedded = await adapters2.embed(redacted.text.slice(0, ABSTRACT_MAX_CHARS));
+    if (embedded.length > 0) segmentEmbedding = embedded;
+  } catch {
+    segmentEmbedding = void 0;
+  }
+  const sourceEventIds = slice.map((e) => e.source_event_id);
+  const id = segmentId(sessionId, startedAtMs, endedAtMs, sourceEventIds);
+  return {
+    segment_id: id,
+    session_id: sessionId,
+    tool: first.tool,
+    started_at: first.ts,
+    ended_at: last.ts,
+    abstract: redacted.text.slice(0, ABSTRACT_MAX_CHARS),
+    tokens,
+    tags,
+    redaction: redacted.counts,
+    source_event_ids: sourceEventIds,
+    abstract_embedding: segmentEmbedding && segmentEmbedding.length === 384 ? segmentEmbedding : void 0
   };
 }
+function turnSurface(e) {
+  const parts = [e.kind, e.tool];
+  if (e.model) parts.push(e.model);
+  const toolCalls = Object.keys(e.tool_calls ?? {});
+  if (toolCalls.length) parts.push(`tools:${toolCalls.join(",")}`);
+  if (e.files_touched?.length) parts.push(`files:${e.files_touched.length}`);
+  return parts.join(" ");
+}
+function cosineDistance(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  return denom > 0 ? 1 - dot / denom : 1;
+}
 function inferEnvironment(branch) {
-  if (!branch) return null;
   const b = branch.toLowerCase();
-  if (b === "main" || b === "master" || b.startsWith("prod")) return "Production";
-  if (b.startsWith("staging") || b.startsWith("stage")) return "Staging";
-  if (b.startsWith("dev") || b === "develop" || b === "development") return "Development";
-  if (b.startsWith("test") || b.startsWith("qa")) return "Testing";
+  if (b === "main" || b === "master" || b.startsWith("release/")) return "Prod";
+  if (b === "staging" || b.startsWith("staging/")) return "Staging";
+  if (b === "dev" || b === "develop" || b.startsWith("dev/")) return "Dev";
   return null;
 }
-function inferWorkType(branch) {
-  if (!branch) return null;
-  for (const { work, re } of WORK_TYPE_PATTERNS) {
-    if (re.test(branch)) return work;
+var SEGMENT_TIME_GAP_MS, SEGMENT_TOPIC_THRESHOLD, SEGMENT_MAX_TURNS, SEGMENT_MAX_DURATION_MS, ABSTRACT_MAX_CHARS;
+var init_pipeline = __esm({
+  "../../packages/companion-core/src/pipeline/index.ts"() {
+    "use strict";
+    init_redact();
+    init_ids();
+    init_redact();
+    init_prompts();
+    SEGMENT_TIME_GAP_MS = 15 * 6e4;
+    SEGMENT_TOPIC_THRESHOLD = 0.35;
+    SEGMENT_MAX_TURNS = 100;
+    SEGMENT_MAX_DURATION_MS = 30 * 6e4;
+    ABSTRACT_MAX_CHARS = 512;
+  }
+});
+
+// ../../packages/companion-core/src/index.ts
+var init_src3 = __esm({
+  "../../packages/companion-core/src/index.ts"() {
+    "use strict";
+    init_contracts();
+    init_ids2();
+    init_logger();
+    init_config();
+    init_http();
+    init_queue();
+    init_pipeline();
+  }
+});
+
+// ../../packages/companion-core/src/node/file-queue-store.ts
+import { promises as fs } from "fs";
+import { dirname as dirname3 } from "path";
+var SENT_TTL_MS;
+var init_file_queue_store = __esm({
+  "../../packages/companion-core/src/node/file-queue-store.ts"() {
+    "use strict";
+    SENT_TTL_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// ../../packages/companion-core/src/node/ollama.ts
+function defaultOllamaConfig() {
+  const base = globalThis.process?.env ?? {};
+  return {
+    baseUrl: base.OLLAMA_URL ?? "http://localhost:11434",
+    embedModel: base.OLLAMA_EMBED_MODEL ?? OLLAMA_EMBED_MODEL,
+    chatModel: base.OLLAMA_CHAT_MODEL ?? OLLAMA_CHAT_MODEL
+  };
+}
+function ollamaEmbed(cfg = defaultOllamaConfig()) {
+  return async (text) => {
+    const res = await fetch(`${cfg.baseUrl.replace(/\/+$/, "")}/api/embeddings`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model: cfg.embedModel, prompt: text })
+    });
+    if (!res.ok) {
+      throw new Error(`ollama embed failed: ${res.status} ${await res.text().catch(() => "")}`);
+    }
+    const body = await res.json();
+    const v = body.embedding ?? [];
+    let norm = 0;
+    for (const x of v) norm += x * x;
+    norm = Math.sqrt(norm) || 1;
+    return v.map((x) => x / norm);
+  };
+}
+function ollamaTokenize() {
+  return (text) => Math.max(1, Math.ceil(text.length / QWEN_CHARS_PER_TOKEN));
+}
+function ollamaSummarize(cfg = defaultOllamaConfig()) {
+  return async ({ prompt, maxTokens }) => {
+    const res = await fetch(`${cfg.baseUrl.replace(/\/+$/, "")}/api/chat`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        model: cfg.chatModel,
+        stream: false,
+        options: {
+          temperature: SUMMARISER_TEMPERATURE,
+          num_predict: Math.min(maxTokens, SUMMARISER_MAX_TOKENS)
+        },
+        messages: [
+          { role: "system", content: SUMMARISER_SYSTEM_PROMPT },
+          { role: "user", content: prompt }
+        ]
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`ollama summarize failed: ${res.status} ${await res.text().catch(() => "")}`);
+    }
+    const body = await res.json();
+    return (body.message?.content ?? "").trim().slice(0, 240);
+  };
+}
+var init_ollama = __esm({
+  "../../packages/companion-core/src/node/ollama.ts"() {
+    "use strict";
+    init_prompts();
   }
-  return null;
+});
+
+// ../../packages/companion-core/src/node/index.ts
+var init_node = __esm({
+  "../../packages/companion-core/src/node/index.ts"() {
+    "use strict";
+    init_file_queue_store();
+    init_file_queue_store();
+    init_ollama();
+  }
+});
+
+// src/pipeline.ts
+function getAdapters() {
+  if (!adapters) {
+    const cfg = defaultOllamaConfig();
+    adapters = {
+      embed: ollamaEmbed(cfg),
+      summarize: ollamaSummarize(cfg),
+      tokenize: ollamaTokenize()
+    };
+  }
+  return adapters;
+}
+async function buildSegments(events) {
+  return buildSegmentsForSession(events, getAdapters());
 }
-var WORK_TYPE_PATTERNS;
-var init_segment = __esm({
-  "src/segment.ts"() {
+var adapters;
+var init_pipeline2 = __esm({
+  "src/pipeline.ts"() {
     "use strict";
-    WORK_TYPE_PATTERNS = [
-      { work: "debugging", re: /\b(fix|bug|debug|hotfix|incident|issue)\b/i },
-      { work: "testing", re: /\b(test|spec|e2e|ci)\b/i },
-      { work: "devops", re: /\b(deploy|infra|docker|k8s|terraform|helm|ci|cd)\b/i },
-      { work: "docs", re: /\b(docs|readme|guide|tutorial)\b/i },
-      { work: "refactoring", re: /\b(refactor|cleanup|lint|format)\b/i },
-      { work: "review", re: /\b(review|pr[-_]?\d+)\b/i },
-      { work: "planning", re: /\b(plan|design|rfc|spec)\b/i },
-      { work: "research", re: /\b(research|spike|prototype|explor)/i }
-    ];
+    init_pipeline();
+    init_node();
+    adapters = null;
   }
 });
 
@@ -5495,7 +8184,6 @@ var init_segment = __esm({
 import { readdir, stat as stat2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-import { ulid as ulid2 } from "ulid";
 async function scanAll(cb = {}) {
   const deviceId = state.deviceId;
   if (!deviceId) throw new Error("agent not enrolled \u2014 run `register` first");
@@ -5556,25 +8244,14 @@ async function scanAll(cb = {}) {
   let buffer = [];
   async function flushBatch() {
     if (!buffer.length) return;
-    const n = buffer.length;
-    cb.onUpload?.(n);
-    const bySession = /* @__PURE__ */ new Map();
-    for (const e of buffer) {
-      const arr = bySession.get(e.session_id);
-      if (arr) arr.push(e);
-      else bySession.set(e.session_id, [e]);
-    }
-    const summaries = {};
-    for (const [sid, evs] of bySession.entries()) {
-      summaries[sid] = summariseSessionEvents({ sourceSessionId: sid, events: evs });
-    }
+    cb.onUpload?.(buffer.length);
+    const segments = await buildSegments(buffer);
     const batch = {
-      batch_id: ulid2(),
+      batch_id: batchId(),
       device_id: deviceId,
       agent_version: AGENT_VERSION,
-      schema_version: 1,
       events: buffer,
-      session_summaries: summaries
+      segments
     };
     const res = await uploadBatch(batch);
     batchesUploaded += 1;
@@ -5612,9 +8289,10 @@ var init_scan = __esm({
   "src/scan.ts"() {
     "use strict";
     init_src2();
-    init_config();
+    init_src3();
+    init_pipeline2();
+    init_config2();
     init_api();
-    init_segment();
     AGENT_VERSION = "agent-dev-0.0.1";
     BATCH_MAX_EVENTS = 2e3;
   }
@@ -5790,7 +8468,7 @@ var init_daemon = __esm({
     "use strict";
     init_src2();
     init_api();
-    init_config();
+    init_config2();
     init_scan();
     AGENT_VERSION2 = "agent-dev-0.0.1";
     HEARTBEAT_INTERVAL_MS = 1e4;
@@ -5903,12 +8581,11 @@ var init_watch = __esm({
 // src/cli.ts
 init_src2();
 init_api();
-init_config();
+init_config2();
 init_scan();
 import { spawn } from "child_process";
 import { randomBytes } from "crypto";
 import { platform as platform4, release, arch as cpuArch, hostname as hostname2 } from "os";
-import { setTimeout as delay } from "timers/promises";
 
 // src/service.ts
 import { spawnSync } from "child_process";
@@ -5920,7 +8597,7 @@ import {
   writeFileSync
 } from "fs";
 import { homedir as homedir3, platform as platform2, userInfo } from "os";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname4, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var SERVICE_LABEL = "ai.modelstat.agent";
 var SYSTEMD_UNIT = "modelstat";
@@ -5961,9 +8638,25 @@ function nodeBinary() {
 function plistPath() {
   return join3(home(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
 }
+function locateTrayExecutable() {
+  const candidates = [
+    join3(home(), "Applications", "ModelstatTray.app", "Contents", "MacOS", "modelstat-tray"),
+    "/Applications/ModelstatTray.app/Contents/MacOS/modelstat-tray"
+  ];
+  for (const p of candidates) {
+    if (existsSync4(p)) return p;
+  }
+  return null;
+}
 function writePlist(cliPath) {
   const p = plistPath();
-  mkdirSync(dirname3(p), { recursive: true });
+  mkdirSync(dirname4(p), { recursive: true });
+  const tray = locateTrayExecutable();
+  const programArgs = tray ? `    <string>${tray}</string>` : [
+    `    <string>${nodeBinary()}</string>`,
+    `    <string>${cliPath}</string>`,
+    `    <string>start</string>`
+  ].join("\n");
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -5971,9 +8664,7 @@ function writePlist(cliPath) {
   <key>Label</key><string>${SERVICE_LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${nodeBinary()}</string>
-    <string>${cliPath}</string>
-    <string>start</string>
+${programArgs}
   </array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key>
@@ -6038,7 +8729,7 @@ function systemdUnitPath() {
 }
 function writeSystemdUnit(cliPath) {
   const unitPath = systemdUnitPath();
-  mkdirSync(dirname3(unitPath), { recursive: true });
+  mkdirSync(dirname4(unitPath), { recursive: true });
   const unit = `[Unit]
 Description=modelstat agent
 Documentation=https://modelstat.ai
@@ -6050,7 +8741,7 @@ Type=simple
 ExecStart=${nodeBinary()} ${cliPath} start
 Restart=always
 RestartSec=10
-# Don't restart-storm if the backend is persistently unreachable.
+# Don't restart-storm if the service is persistently unreachable.
 StartLimitIntervalSec=300
 StartLimitBurst=10
 StandardOutput=append:${join3(logDir(), "out.log")}
@@ -6121,6 +8812,55 @@ function serviceStatus() {
 function logsDir() {
   return logDir();
 }
+function installTrayApp(sourceAppPath) {
+  if (platform2() !== "darwin") return null;
+  if (!existsSync4(sourceAppPath)) return null;
+  const dest = join3(home(), "Applications", "ModelstatTray.app");
+  mkdirSync(dirname4(dest), { recursive: true });
+  spawnSync("rm", ["-rf", dest]);
+  const r = spawnSync("cp", ["-R", sourceAppPath, dest], { encoding: "utf8" });
+  if (r.status !== 0) {
+    throw new Error(`cp ModelstatTray.app failed: ${r.stderr?.trim() || `exit ${r.status}`}`);
+  }
+  return { installedAt: dest };
+}
+function bundledTrayAppPath() {
+  if (platform2() !== "darwin") return null;
+  const here2 = dirname4(fileURLToPath2(import.meta.url));
+  const candidates = [
+    // Pre-built .app — CI with codesigning drops one here.
+    join3(here2, "..", "vendor", "ModelstatTray.app"),
+    // Local dev layout: apps/agent-dev/src/service.ts → ../../tray-mac/build/ModelstatTray.app
+    join3(here2, "..", "..", "tray-mac", "build", "ModelstatTray.app")
+  ];
+  for (const c of candidates) {
+    if (existsSync4(c)) return c;
+  }
+  const sourceDirs = [
+    join3(here2, "..", "vendor", "tray-mac"),
+    join3(here2, "..", "..", "tray-mac")
+  ];
+  for (const src of sourceDirs) {
+    const build = join3(src, "build-app.sh");
+    if (!existsSync4(build)) continue;
+    if (!hasSwift()) return null;
+    const r = spawnSync("bash", [build], { cwd: src, encoding: "utf8" });
+    if (r.status === 0) {
+      const app = join3(src, "build", "ModelstatTray.app");
+      if (existsSync4(app)) return app;
+    }
+  }
+  return null;
+}
+function hasSwift() {
+  const r = spawnSync("swift", ["--version"], { encoding: "utf8" });
+  return r.status === 0;
+}
+function trayStatus() {
+  if (platform2() !== "darwin") return { installed: false, path: null };
+  const exe = locateTrayExecutable();
+  return exe ? { installed: true, path: exe.replace(/\/Contents\/MacOS\/modelstat-tray$/, "") } : { installed: false, path: null };
+}
 
 // src/cli.ts
 function tryOpenBrowser(url) {
@@ -6168,6 +8908,7 @@ function generateUuidV7() {
 }
 async function cmdSelfRegister() {
   const deviceUuid = state.deviceUuid ?? generateUuidV7();
+  const fresh = !state.deviceUuid;
   const fingerprint = {
     hostname: hostname2(),
     os_family: osFamily(),
@@ -6176,6 +8917,14 @@ async function cmdSelfRegister() {
     agent: "modelstat-agent-dev",
     agent_version: AGENT_VERSION3
   };
+  if (fresh) {
+    process.stdout.write(`  \x1B[2mgenerated UUIDv7 ${deviceUuid.slice(0, 8)}\u2026\x1B[0m
+`);
+  }
+  process.stdout.write(
+    `  \x1B[2m\u2192 POST ${state.apiUrl}/v1/devices/self-register\x1B[0m
+`
+  );
   const res = await selfRegister({
     device_uuid: deviceUuid,
     fingerprint
@@ -6185,16 +8934,12 @@ async function cmdSelfRegister() {
   state.setBearer(res.device_secret);
   state.setClaimCode(res.claim_code);
   state.setClaimUrl(res.claim_url);
-  console.log(`\u2713 self-registered`);
-  console.log(`  device_uuid:    ${res.device_uuid}`);
-  console.log(`  device_id:      ${res.device_id}`);
-  console.log(`  secret_prefix:  ${res.secret_prefix}\u2026`);
-  console.log();
-  console.log(`  Claim this device to attach it to your account:`);
-  console.log(`    ${res.claim_url}`);
-  console.log(`    code: ${res.claim_code}`);
-  console.log();
-  console.log(`  state: ${state.storePath}`);
+  process.stdout.write(`  \x1B[32m\u2713\x1B[0m registered  device_id=${res.device_id}
+`);
+  process.stdout.write(`  \x1B[32m\u2713\x1B[0m secret      ${res.secret_prefix}\u2026  (hashed on server, never re-sent)
+`);
+  process.stdout.write(`  \x1B[32m\u2713\x1B[0m claim code  ${res.claim_code}
+`);
 }
 async function cmdAwaitClaim() {
   const secret = state.bearer;
@@ -6212,7 +8957,7 @@ async function cmdAwaitClaim() {
       me = await fetchDeviceMe(secret);
     } catch (e) {
       console.error(`poll failed: ${e.message}`);
-      await delay(5e3);
+      await new Promise((r) => setTimeout(r, 5e3));
       continue;
     }
     if (me.status === "claimed") {
@@ -6220,33 +8965,9 @@ async function cmdAwaitClaim() {
       return;
     }
     process.stdout.write(".");
-    await delay(2e3);
-  }
-}
-async function cmdRegister() {
-  const email = defaultUserEmail();
-  const res = await enrollDevice({
-    machine_id: machineId(),
-    hostname: hostname2(),
-    os_family: osFamily(),
-    os_version: release(),
-    arch: osArch(),
-    agent_version: AGENT_VERSION3,
-    user_email: email
-  });
-  if (!res.bearer_token || !res.device_id) {
-    throw new Error("enroll response missing bearer or device_id");
+    await new Promise((r) => setTimeout(r, 2e3));
   }
-  state.setBearer(res.bearer_token);
-  state.setDeviceId(res.device_id);
-  state.setUserEmail(email);
-  console.log(`\u2713 device enrolled (dev-shortcut)`);
-  console.log(`  user_id:   ${res.user_id}`);
-  console.log(`  device_id: ${res.device_id}`);
-  console.log(`  bearer:    ${res.bearer_token.slice(0, 16)}\u2026`);
-  console.log(`  state:     ${state.storePath}`);
 }
-var DASHBOARD_URL = "https://modelstat.ai/dashboard";
 function emitEvent(opts, event, fields = {}) {
   if (!opts.json) return;
   process.stdout.write(
@@ -6255,8 +8976,38 @@ function emitEvent(opts, event, fields = {}) {
   );
 }
 async function cmdConnect(opts) {
+  const step = (msg) => {
+    if (opts.json) return;
+    process.stdout.write(`\x1B[1;36m\u25B8\x1B[0m ${msg}
+`);
+  };
+  const ok = (msg) => {
+    if (opts.json) return;
+    process.stdout.write(`  \x1B[32m\u2713\x1B[0m ${msg}
+`);
+  };
+  const warn = (msg) => {
+    if (opts.json) return;
+    process.stdout.write(`  \x1B[33m\u26A0\x1B[0m ${msg}
+`);
+  };
+  const hasLegacyBearer = !!state.bearer && !state.bearer.startsWith("ds_live_");
+  const hasLegacyClaim = !!state.claimUrl && state.claimUrl.includes("/c/");
+  if (hasLegacyBearer || hasLegacyClaim) {
+    step("Legacy state detected from an older version \u2014 wiping");
+    state.setBearer(null);
+    state.setDeviceId(null);
+    state.setDeviceUuid(null);
+    state.setClaimCode(null);
+    state.setClaimUrl(null);
+    ok("clean slate");
+  }
   if (!state.deviceUuid || !state.bearer || !state.deviceId) {
+    step("Registering this device with modelstat.ai");
     await cmdSelfRegister();
+  } else {
+    step("Re-using existing device identity");
+    ok(`device ${state.deviceId}`);
   }
   const claimCode = state.claimCode ?? "(unknown)";
   const claimUrl = state.claimUrl ?? `https://modelstat.ai/d/${claimCode}`;
@@ -6268,23 +9019,60 @@ async function cmdConnect(opts) {
     claim_url: claimUrl,
     agent_url: agentUrl
   });
+  if (platform4() === "darwin") {
+    step("Installing menu-bar tray (macOS)");
+    try {
+      const src = bundledTrayAppPath();
+      if (src) {
+        const out = installTrayApp(src);
+        if (out) {
+          emitEvent(opts, "tray_installed", { path: out.installedAt });
+          ok(`tray at ${out.installedAt}`);
+        }
+      } else {
+        emitEvent(opts, "tray_not_bundled", {});
+        warn("no bundled tray \u2014 skipping (install Xcode CLI tools and re-run to get the icon)");
+      }
+    } catch (e) {
+      emitEvent(opts, "tray_install_failed", { error: e.message });
+      warn(`tray install skipped: ${e.message}`);
+    }
+  }
+  step("Installing background service so the agent survives reboots");
   let serviceOk = false;
   try {
     const svc = installService();
     serviceOk = true;
     emitEvent(opts, "service_installed", { path: svc.path, logs: svc.logs });
+    ok(`${platform4() === "darwin" ? "launchd" : "systemd --user"}: ${svc.path}`);
   } catch (e) {
     emitEvent(opts, "service_install_failed", { error: e.message });
+    warn(`couldn't install service: ${e.message}`);
+    warn("will run in the foreground instead \u2014 don't close this terminal");
   }
   if (!opts.json) {
+    const tray = trayStatus();
     const line = "\u2501".repeat(60);
     console.log();
     console.log(line);
     console.log(`  \u2713 Device registered \u2014 streaming your AI usage to modelstat.`);
     console.log();
+    console.log(
+      `    service : \x1B[${serviceOk ? "32" : "33"}m${serviceOk ? "installed" : "foreground"}\x1B[0m`
+    );
+    if (platform4() === "darwin") {
+      console.log(
+        `    tray    : \x1B[${tray.installed ? "32" : "2"}m${tray.installed ? "menu-bar icon ready" : "not installed"}\x1B[0m`
+      );
+    }
+    console.log();
     console.log(`  Open your dashboard (no sign-up needed):`);
     console.log(`    \x1B[1;36m${claimUrl}\x1B[0m`);
     console.log();
+    console.log(`  Live numbers from this terminal:`);
+    console.log(`    \x1B[2mmodelstat stats\x1B[0m   # sessions \xB7 tokens \xB7 cost`);
+    console.log(`    \x1B[2mmodelstat jobs\x1B[0m    # pipeline queue + recent activity`);
+    console.log();
     console.log(`  Agent-friendly (for LLMs / MCPs):`);
     console.log(`    \x1B[2m${agentUrl}\x1B[0m`);
     console.log();
@@ -6310,164 +9098,6 @@ async function cmdConnect(opts) {
   const { runDaemon: runDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
   await runDaemon2();
 }
-async function cmdConnectOAuth(opts) {
-  const init = await startDeviceCode();
-  const url = init.verification_url;
-  emitEvent(opts, "device_code_issued", {
-    verification_url: url,
-    user_code: init.user_code,
-    expires_in: init.expires_in,
-    interval: init.interval
-  });
-  const opened = opts.noBrowser ? false : tryOpenBrowser(url);
-  if (!opts.noBrowser) {
-    emitEvent(opts, "browser_open_attempted", { opened });
-  }
-  if (!opts.json) {
-    const line = "\u2501".repeat(60);
-    console.log();
-    console.log(line);
-    console.log(
-      opened ? "  Opening your browser to approve this device\u2026" : "  Open this URL in any browser to approve this device:"
-    );
-    console.log();
-    console.log(`    \x1B[1;36m${url}\x1B[0m`);
-    console.log();
-    console.log("  Pairing code:");
-    console.log(`    \x1B[1;33m${init.user_code}\x1B[0m`);
-    console.log();
-    console.log(`  Waiting for approval (expires in ${init.expires_in}s)`);
-    console.log(line);
-    console.log();
-  }
-  const deadline = Date.now() + init.expires_in * 1e3;
-  let dots = 0;
-  let lastPollEmit = 0;
-  while (Date.now() < deadline) {
-    await delay(init.interval * 1e3);
-    try {
-      const res = await pollDeviceCode(init.device_code);
-      if (res.status === "approved") {
-        state.setBearer(res.bearer_token);
-        state.setUserEmail(`user:${res.user_id}`);
-        emitEvent(opts, "approved", { user_id: res.user_id });
-        if (!opts.json) {
-          console.log();
-          console.log("\u2713 approved \u2014 bearer stored");
-        }
-        let enroll = null;
-        try {
-          enroll = await enrollDevice({
-            machine_id: machineId(),
-            hostname: hostname2(),
-            os_family: osFamily(),
-            os_version: release(),
-            arch: osArch(),
-            agent_version: AGENT_VERSION3
-          });
-        } catch (e) {
-          const message = e.message;
-          emitEvent(opts, "error", { code: "enroll_failed", message });
-          if (!opts.json) {
-            console.error();
-            console.error(`\u2717 device enrollment failed: ${message}`);
-            console.error(
-              "  The approval went through but the server couldn't register this"
-            );
-            console.error(
-              "  machine. Check that your modelstat API is reachable at"
-            );
-            console.error(`  ${state.apiUrl} \u2014 then run \`modelstat connect\` again.`);
-          }
-          process.exit(1);
-        }
-        if (!enroll?.device_id) {
-          emitEvent(opts, "error", {
-            code: "enroll_failed",
-            message: "enrollment returned no device_id"
-          });
-          if (!opts.json) {
-            console.error("\n\u2717 enrollment returned no device_id. Aborting.");
-          }
-          process.exit(1);
-        }
-        state.setDeviceId(enroll.device_id);
-        emitEvent(opts, "device_enrolled", { device_id: enroll.device_id });
-        if (!opts.json) {
-          console.log(`\u2713 device registered  (${enroll.device_id.slice(0, 8)}\u2026)`);
-        }
-        try {
-          const svc = installService();
-          emitEvent(opts, "service_installed", {
-            path: svc.path,
-            logs: svc.logs
-          });
-          if (!opts.json) {
-            console.log(`\u2713 service installed    (${svc.path})`);
-            console.log(`  logs:                ${svc.logs}`);
-            console.log();
-            const banner = "\u2501".repeat(60);
-            console.log(banner);
-            console.log("  You're connected. The agent is now running in the");
-            console.log("  background and will start on login.");
-            console.log();
-            console.log("  Manage it from the dashboard:");
-            console.log(`    \x1B[1;36m${DASHBOARD_URL}\x1B[0m`);
-            console.log();
-            console.log("  Stop it any time:   \x1B[2mmodelstat stop\x1B[0m");
-            console.log("  Uninstall:          \x1B[2mmodelstat uninstall\x1B[0m");
-            console.log(banner);
-          }
-          emitEvent(opts, "done", { dashboard_url: DASHBOARD_URL });
-          return;
-        } catch (err) {
-          const message = err.message;
-          emitEvent(opts, "service_install_failed", {
-            error: message,
-            fallback: opts.json ? "manual" : "foreground"
-          });
-          if (opts.json) {
-            emitEvent(opts, "done", { dashboard_url: DASHBOARD_URL });
-            return;
-          }
-          console.warn();
-          console.warn(`\u26A0 couldn't install as a background service: ${message}`);
-          console.warn("  Running in the foreground instead \u2014 press Ctrl-C to stop.");
-          console.warn("  (Install globally with `npm i -g modelstat` then re-run `modelstat connect`.)");
-          console.warn();
-          const { runDaemon: runDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
-          await runDaemon2();
-          return;
-        }
-      }
-    } catch (e) {
-      if (dots % 15 === 0 && !opts.json) {
-        console.warn(`
-[retry] ${e.message}`);
-      }
-    }
-    dots += 1;
-    if (opts.json) {
-      const now = Date.now();
-      if (now - lastPollEmit >= 1e4) {
-        emitEvent(opts, "polling", {
-          seconds_remaining: Math.max(0, Math.round((deadline - now) / 1e3))
-        });
-        lastPollEmit = now;
-      }
-    } else {
-      process.stdout.write(".");
-    }
-  }
-  emitEvent(opts, "error", {
-    code: "device_code_expired",
-    message: "device_code expired before approval"
-  });
-  if (!opts.json) {
-    console.error("\ndevice_code expired before approval");
-  }
-  process.exit(1);
-}
 async function cmdDiscover() {
   const deviceId = state.deviceId;
   if (!deviceId) throw new Error("run `register` first");
@@ -6525,6 +9155,113 @@ async function cmdStatus() {
   console.log(`state:   ${state.storePath}`);
   console.log(`api:     ${state.apiUrl}`);
 }
+function fmtInt(n) {
+  return Number(n).toLocaleString("en-US");
+}
+function fmtCost(usd) {
+  return `$${usd.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function fmtTokens(v) {
+  const n = typeof v === "string" ? Number(v) : v;
+  if (!Number.isFinite(n)) return "\u2014";
+  if (n >= 1e9) return `${(n / 1e9).toFixed(n >= 1e10 ? 0 : 1)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(n >= 1e7 ? 0 : 1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(n);
+}
+async function cmdStats(args) {
+  const asJson = args.includes("--json");
+  const claim = state.claimCode;
+  if (!claim) {
+    if (asJson) {
+      process.stdout.write(`${JSON.stringify({ paired: false, reason: "no_claim_code" })}
+`);
+    } else {
+      console.log("no claim code on record \u2014 run `modelstat connect` first");
+    }
+    return;
+  }
+  const view = await fetchDeviceViewByClaim(claim);
+  if (!view) {
+    const dashboard = `${state.apiUrl.replace(/\/$/, "")}/dashboard`;
+    if (asJson) {
+      process.stdout.write(
+        `${JSON.stringify({ paired: true, claimed: true, dashboard })}
+`
+      );
+    } else {
+      console.log("device is claimed \u2014 live stats available at:");
+      console.log(`  ${dashboard}`);
+    }
+    return;
+  }
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify(view)}
+`);
+    return;
+  }
+  console.log(`device:   ${view.device.id}`);
+  console.log(`host:     ${view.device.hostname ?? "(unknown)"} (${view.device.os_family ?? "?"})`);
+  console.log(`agent:    ${view.device.agent_version ?? "(unknown)"}`);
+  console.log(
+    `status:   ${view.device.agent_status ?? "(unknown)"}${view.device.last_seen_at ? ` \xB7 last seen ${view.device.last_seen_at}` : ""}`
+  );
+  console.log(`claim:    ${view.status}${view.status === "unclaimed" ? ` (at ${view.claim_url})` : ""}`);
+  console.log(`sessions: ${fmtInt(view.analyzed.count)}`);
+  console.log(`tokens:   ${fmtTokens(view.analyzed.totalTokens)}`);
+  console.log(`cost:     ${fmtCost(view.analyzed.totalCostUsd)}`);
+  console.log(`quota:    ${fmtTokens(view.free_quota_tokens)} free-tier ceiling`);
+}
+async function cmdJobs(args) {
+  const asJson = args.includes("--json");
+  const claim = state.claimCode;
+  if (!claim) {
+    if (asJson) {
+      process.stdout.write(`${JSON.stringify({ paired: false, reason: "no_claim_code" })}
+`);
+    } else {
+      console.log("no claim code on record \u2014 run `modelstat connect` first");
+    }
+    return;
+  }
+  const [jobs, ledger] = await Promise.all([
+    fetchDeviceViewJobsByClaim(claim),
+    fetchDeviceViewLedgerByClaim(claim)
+  ]);
+  if (!jobs && !ledger) {
+    const dashboard = `${state.apiUrl.replace(/\/$/, "")}/dashboard/jobs`;
+    if (asJson) {
+      process.stdout.write(
+        `${JSON.stringify({ paired: true, claimed: true, dashboard })}
+`
+      );
+    } else {
+      console.log("device is claimed \u2014 job queue at:");
+      console.log(`  ${dashboard}`);
+    }
+    return;
+  }
+  if (asJson) {
+    process.stdout.write(
+      `${JSON.stringify({ jobs: jobs ?? null, ledger: ledger?.recent ?? [] })}
+`
+    );
+    return;
+  }
+  console.log(`queue:   ${jobs?.pending ?? 0} pending \xB7 ${jobs?.running ?? 0} running`);
+  const recent = ledger?.recent ?? [];
+  if (recent.length === 0) {
+    console.log("ledger:  (no activity yet)");
+    return;
+  }
+  console.log(`ledger:  (last ${recent.length})`);
+  for (const r of recent.slice(0, 15)) {
+    const ts = r.occurred_at.slice(0, 19).replace("T", " ");
+    console.log(
+      `  ${ts}  ${r.kind.padEnd(16)}  ${fmtTokens(r.tokens).padStart(7)} tok  ${r.session_id ?? ""}`
+    );
+  }
+}
 function cmdPaths(args) {
   const data = {
     state: state.storePath,
@@ -6544,11 +9281,7 @@ function cmdPaths(args) {
 function parseConnectOpts(argv) {
   return {
     json: argv.includes("--json"),
-    noBrowser: argv.includes("--no-browser"),
-    // --oauth selects the legacy device-code flow (for users who
-    // already have an account and want to stream straight into their
-    // personal org). Default is the new self-register flow.
-    oauth: argv.includes("--oauth")
+    noBrowser: argv.includes("--no-browser")
   };
 }
 async function main() {
@@ -6560,12 +9293,8 @@ async function main() {
       if (!state.bearer || !state.deviceId)
         return cmdConnect(parseConnectOpts(rest));
       return cmdStart();
-    case "connect": {
-      const opts = parseConnectOpts(rest);
-      return opts.oauth ? cmdConnectOAuth(opts) : cmdConnect(opts);
-    }
-    case "register":
-      return cmdRegister();
+    case "connect":
+      return cmdConnect(parseConnectOpts(rest));
     case "self-register":
       return cmdSelfRegister();
     case "await-claim":
@@ -6581,28 +9310,32 @@ async function main() {
       return cmdStop();
     case "status":
       return cmdStatus();
+    case "stats":
+      return cmdStats(rest);
+    case "jobs":
+      return cmdJobs(rest);
     case "paths":
       cmdPaths(rest);
       return;
     default:
       console.log(
-        "usage: modelstat [connect|self-register|await-claim|status|paths|stop|start|discover|scan|watch|register]"
+        "usage: modelstat [connect|self-register|await-claim|status|stats|jobs|paths|stop|start|discover|scan|watch]"
       );
       console.log();
       console.log("  (no args)       \u2014 pair if needed, then run the daemon in the foreground");
-      console.log("  connect         \u2014 OAuth device-code pair + install service, then exit");
+      console.log("  connect         \u2014 self-register + install the background service; prints /d/:claim_code URL");
       console.log("                    flags: --json (NDJSON events on stdout), --no-browser");
-      console.log("  self-register   \u2014 agent-first: generate UUIDv7, get device_secret + claim code");
-      console.log("                    (no human required for the first call)");
+      console.log("  self-register   \u2014 generate UUIDv7 + register; print claim URL and exit");
       console.log("  await-claim     \u2014 block until a human claims this self-registered device");
       console.log("  status          \u2014 show pairing + service state");
+      console.log("  stats           \u2014 live device summary: sessions, tokens, cost (use --json)");
+      console.log("  jobs            \u2014 pipeline queue + recent processing ledger (use --json)");
       console.log("  paths           \u2014 print state file + log dir + api URL (use --json for machine-readable)");
       console.log("  stop            \u2014 stop and uninstall the background service");
       console.log("  start           \u2014 run the daemon (used by the installed service)");
       console.log("  discover        \u2014 one-shot report of installs/identities");
       console.log("  scan            \u2014 one-shot parse + upload of local JSONL");
       console.log("  watch           \u2014 continuous (chokidar) with periodic backstop");
-      console.log("  register        \u2014 DEV shortcut (email-only, no OAuth)");
       process.exit(1);
   }
 }