tokentracker-cli 0.79.9 → 0.80.1

package/src/commands/sync.js

@@ -172,6 +172,18 @@ const CLOUD_CONVERSATIONS_BACKFILL_KEY = "cloudConversationsBackfill_2026_06";
 // ~/.codex/archived_sessions/ which sync does not scan) — clearing its bucket
 // would lose that history (ref the v6 ground-truth-repair data-loss incident).
 const CODEX_RESCAN_DEDUP_REPAIR_KEY = "codexRescanDedupRepair_2026_06";
+// One-time repair (#169 follow-up): forked Codex rollouts replay the parent
+// session's token history into the child file, and until the same-day burst
+// detector landed in rollout.js the parser counted those replayed rows as live
+// usage (PR #169's date guard only caught cross-day forks). Cursors sit at EOF
+// on every already-parsed file, so the forward fix alone never corrects the
+// inflated history. This re-runs the exact #187 guarded rebuild under a new key
+// — the rebuild re-parses every codex file with the CURRENT (fork-aware)
+// parser, so replay rows are excluded — and inherits all its safety properties
+// (unreproducible-session skip, atomic throwaway rebuild, queue strip, upload
+// offset reset for the cloud overwrite). Pre-gated: installs with no forked
+// rollout on disk carry no fork phantom and mark done without the rebuild.
+const CODEX_FORK_REPLAY_REPAIR_KEY = "codexForkReplayRepair_2026_07";
 const DROID_DUP_SESSION_REPAIR_KEY = "droidDupSessionInflationRepair_2026_06";
 const CODEX_COLD_SCAN_AUDIT_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const CODEX_COLD_SCAN_AUDIT_MAX_SYNCS = 288;
@@ -273,8 +285,10 @@ function mergeCopilotAppDbStates(primary = {}, alias = {}) {
   return { ...primary, ...newer, sessionTotals };
 }
 
-async function cmdSync(argv) {
+async function cmdSync(argv, context = {}) {
   const opts = parseArgs(argv);
+  const diagnostics = context && typeof context === "object" ? context.diagnostics : null;
+  const syncDiagnostics = diagnostics && typeof diagnostics === "object" ? diagnostics : null;
   const home = os.homedir();
   const { trackerDir } = await resolveTrackerPaths({ home });
 
@@ -405,7 +419,7 @@ async function cmdSync(argv) {
 
     if (isFullSourceScan) {
       await migrateRolloutCumulativeDeltaBuckets({ cursors, queuePath, rolloutFiles });
-      await repairCodexRescanInflation({
+      const codexRescanRepairRan = await repairCodexRescanInflation({
         cursors,
         queuePath,
         queueStatePath,
@@ -413,6 +427,15 @@ async function cmdSync(argv) {
         projectQueueStatePath,
         rolloutFiles,
       });
+      await repairCodexForkReplayInflation({
+        cursors,
+        queuePath,
+        queueStatePath,
+        projectQueuePath,
+        projectQueueStatePath,
+        rolloutFiles,
+        legacyRepairRan: codexRescanRepairRan,
+      });
       await repairDroidDuplicateSessionInflation({ cursors, queuePath, queueStatePath });
       await repairMimoClaudeMislabel({
         cursors,
@@ -433,6 +456,7 @@ async function cmdSync(argv) {
           cursors,
           projectEnabled: true,
           auditDue: codexColdAuditDue,
+          diagnostics: syncDiagnostics,
         })
       : { rolloutFiles, skipped: 0 };
     const rolloutFilesForParse = codexColdFilter.rolloutFiles;
@@ -455,6 +479,7 @@ async function cmdSync(argv) {
         cursors,
         queuePath,
         projectQueuePath,
+        diagnostics: syncDiagnostics,
         onProgress: (p) => {
           if (!progress?.enabled) return;
           const pct = p.total > 0 ? p.index / p.total : 1;
@@ -1827,6 +1852,12 @@ async function cmdSync(argv) {
 
     cursors.updatedAt = new Date().toISOString();
     await writeJson(cursorsPath, cursors);
+    if (syncDiagnostics) {
+      const cursorStat = await fs.stat(cursorsPath);
+      syncDiagnostics.cursor_commits = Number(syncDiagnostics.cursor_commits || 0) + 1;
+      syncDiagnostics.cursor_bytes = Number(syncDiagnostics.cursor_bytes || 0) + cursorStat.size;
+      syncDiagnostics.cursor_path = cursorsPath;
+    }
     if (grokHookSignalConsumed && grokHookSignalPath) {
       await fs.unlink(grokHookSignalPath).catch(() => {});
     }
@@ -2097,6 +2128,7 @@ module.exports = {
   migrateCursorUnknownBuckets,
   migrateRolloutCumulativeDeltaBuckets,
   repairCodexRescanInflation,
+  repairCodexForkReplayInflation,
   repairDroidDuplicateSessionInflation,
   repairMimoClaudeMislabel,
   reincludeClaudeMemObserverFiles,
@@ -2109,6 +2141,7 @@ module.exports = {
   CURSOR_UNKNOWN_MIGRATION_KEY,
   ROLLOUT_CUMULATIVE_DELTA_MIGRATION_KEY,
   CODEX_RESCAN_DEDUP_REPAIR_KEY,
+  CODEX_FORK_REPLAY_REPAIR_KEY,
   DROID_DUP_SESSION_REPAIR_KEY,
   CLAUDE_MEM_OBSERVER_REINCLUDE_KEY,
   GROK_APPEND_ONLY_REPAIR_MIGRATION_KEY,
@@ -3091,6 +3124,11 @@ async function migrateRolloutCumulativeDeltaBuckets({ cursors, queuePath, rollou
       delete cursors.files[filePath];
     }
   }
+  // The migration clears Codex buckets and reparses the discovered corpus from
+  // byte zero. Persisted event keys belong to the cleared buckets, so retaining
+  // them can suppress the rebuild when a moved session still has an old path
+  // cursor. Rebuild the hash inventory together with the buckets.
+  cursors.codexHashes = [];
 
   const buckets = cursors.hourly?.buckets;
   const retractions = [];
@@ -3157,6 +3195,11 @@ async function repairCodexRescanInflation({
   projectQueuePath,
   projectQueueStatePath,
   rolloutFiles,
+  // The fork-replay repair (#169 follow-up) re-runs this exact rebuild under
+  // its own key: the rebuild always uses the CURRENT parser, so any parser fix
+  // shipped since the last run is applied to the rebuilt history.
+  migrationKey = CODEX_RESCAN_DEDUP_REPAIR_KEY,
+  uploadNote = "reset_after_codex_rescan_dedup_2026_06",
 }) {
   if (!cursors || typeof cursors !== "object") return false;
   const migrations = (cursors.migrations ||= {});
@@ -3167,7 +3210,7 @@ async function repairCodexRescanInflation({
   // found). Treating the skip sentinel as "done" is what left users like #187
   // permanently stuck on the inflated value after upgrading (the key was truthy
   // so the guard never got a second chance).
-  const priorRepair = migrations[CODEX_RESCAN_DEDUP_REPAIR_KEY];
+  const priorRepair = migrations[migrationKey];
   if (priorRepair && !(typeof priorRepair === "object" && priorRepair.skipped)) return false;
 
   // Codex session files THIS sync discovered (source === "codex").
@@ -3203,7 +3246,7 @@ async function repairCodexRescanInflation({
       if (codexFileSet.has(fp)) continue; // exact file re-scanned this run
       const id = codexSessionIdFromPath(fp);
       if (id && scannedSessionIds.has(id)) continue; // same session scanned elsewhere (moved)
-      migrations[CODEX_RESCAN_DEDUP_REPAIR_KEY] = {
+      migrations[migrationKey] = {
         skipped: true,
         reason: "codex_session_unreproducible",
         at: new Date().toISOString(),
@@ -3462,7 +3505,7 @@ async function repairCodexRescanInflation({
     }
     uploadState.offset = 0;
     uploadState.updatedAt = new Date().toISOString();
-    uploadState.note = "reset_after_codex_rescan_dedup_2026_06";
+    uploadState.note = uploadNote;
     await fs.writeFile(queueStatePath, JSON.stringify(uploadState));
   }
   if (projectRepairEnabled && typeof projectQueueStatePath === "string" && projectQueueStatePath) {
@@ -3474,14 +3517,140 @@ async function repairCodexRescanInflation({
     }
     uploadState.offset = 0;
     uploadState.updatedAt = new Date().toISOString();
-    uploadState.note = "reset_after_codex_rescan_dedup_2026_06";
+    uploadState.note = uploadNote;
     await fs.writeFile(projectQueueStatePath, JSON.stringify(uploadState));
   }
 
-  migrations[CODEX_RESCAN_DEDUP_REPAIR_KEY] = new Date().toISOString();
+  migrations[migrationKey] = new Date().toISOString();
   return true;
 }
 
+// #169 follow-up: repair the historical inflation left by same-day forked
+// Codex rollout replays (see CODEX_FORK_REPLAY_REPAIR_KEY). Delegates to the
+// #187 guarded rebuild with the fork-repair key.
+async function repairCodexForkReplayInflation({
+  cursors,
+  queuePath,
+  queueStatePath,
+  projectQueuePath,
+  projectQueueStatePath,
+  rolloutFiles,
+  // True when the #187 repair ran its rebuild earlier in THIS sync: that
+  // rebuild already used the fork-aware parser, so the history is clean and a
+  // second rebuild would be pure waste.
+  legacyRepairRan = false,
+}) {
+  if (!cursors || typeof cursors !== "object") return false;
+  const migrations = (cursors.migrations ||= {});
+  // Same completed-vs-skipped semantics as the #187 repair: an ISO string is
+  // final, a {skipped:true} sentinel retries (the skip condition can clear).
+  const prior = migrations[CODEX_FORK_REPLAY_REPAIR_KEY];
+  if (prior && !(typeof prior === "object" && prior.skipped)) return false;
+
+  if (legacyRepairRan) {
+    migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = new Date().toISOString();
+    return false;
+  }
+
+  // Pre-gate: fork phantom can only exist on installs that have (or had) a
+  // forked rollout. Scanning file heads is cheap; the rebuild re-parses every
+  // codex file. Files forked AFTER the parser fix shipped never accrue
+  // phantom, so a definitive "no forks" verdict may finalize — but ONLY when
+  // this scan can actually stand for the install's whole codex history:
+  //   1. every candidate head was readable (an unreadable candidate could be
+  //      the one forked rollout), AND
+  //   2. every codex session recorded in cursors is covered by THIS scan's
+  //      file list (same UUID-keyed reproducibility rule as the #187 guard).
+  //      A forked rollout can be real yet absent from one run's rolloutFiles —
+  //      WSL/native split probing, a temporarily missing ~/.codex, a deleted
+  //      file whose phantom is already in history — and finalizing off such a
+  //      partial view would permanently foreclose the repair this migration
+  //      exists to perform, while the guarded repair itself would only have
+  //      deferred retryably.
+  // Either failure defers with the retryable {skipped:true} sentinel.
+  const forkScan = await scanForForkedCodexRollout(rolloutFiles);
+  if (!forkScan.forked) {
+    if (forkScan.indeterminate) {
+      migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = {
+        skipped: true,
+        reason: "fork_scan_indeterminate",
+        at: new Date().toISOString(),
+      };
+      return false;
+    }
+    const scannedSessionIds = new Set();
+    const scannedPaths = new Set();
+    for (const entry of Array.isArray(rolloutFiles) ? rolloutFiles : []) {
+      const fp = typeof entry === "string" ? entry : entry?.path;
+      const src = typeof entry === "string" ? "codex" : String(entry?.source || "codex");
+      if (!fp || src !== "codex") continue;
+      scannedPaths.add(fp);
+      const id = codexSessionIdFromPath(fp);
+      if (id) scannedSessionIds.add(id);
+    }
+    if (cursors.files && typeof cursors.files === "object") {
+      for (const fp of Object.keys(cursors.files)) {
+        if (!isCodexSessionCursorPath(fp)) continue;
+        if (scannedPaths.has(fp)) continue;
+        const id = codexSessionIdFromPath(fp);
+        if (id && scannedSessionIds.has(id)) continue;
+        migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = {
+          skipped: true,
+          reason: "codex_history_not_covered",
+          at: new Date().toISOString(),
+        };
+        return false;
+      }
+    }
+    migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = new Date().toISOString();
+    return false;
+  }
+
+  return repairCodexRescanInflation({
+    cursors,
+    queuePath,
+    queueStatePath,
+    projectQueuePath,
+    projectQueueStatePath,
+    rolloutFiles,
+    migrationKey: CODEX_FORK_REPLAY_REPAIR_KEY,
+    uploadNote: "reset_after_codex_fork_replay_2026_07",
+  });
+}
+
+// Scans codex rollout heads for the fork marker. The child session_meta (with
+// forked_from_id) is the FIRST line of a forked rollout — observed at byte
+// offset ≤169 across every local sample — so a bounded head read is
+// sufficient. 64KB leaves ample margin for long base_instructions preceding
+// it; a substring false positive (the marker quoted in unrelated head content)
+// only costs one redundant guarded rebuild, never data. Tri-state result:
+// {forked:true} on a hit, {forked:false, indeterminate:false} only when every
+// candidate was inspected, {forked:false, indeterminate:true} when any head
+// read failed — the caller must not finalize "no forks" off a failed read.
+async function scanForForkedCodexRollout(rolloutFiles) {
+  const HEAD_BYTES = 65536;
+  let indeterminate = false;
+  for (const entry of Array.isArray(rolloutFiles) ? rolloutFiles : []) {
+    const fp = typeof entry === "string" ? entry : entry?.path;
+    const src = typeof entry === "string" ? "codex" : String(entry?.source || "codex");
+    if (!fp || src !== "codex") continue;
+    let fh = null;
+    try {
+      fh = await fs.open(fp, "r");
+      const buf = Buffer.alloc(HEAD_BYTES);
+      const { bytesRead } = await fh.read(buf, 0, HEAD_BYTES, 0);
+      if (buf.toString("utf8", 0, bytesRead).includes('"forked_from_id"')) {
+        return { forked: true, indeterminate: false };
+      }
+    } catch (_e) {
+      indeterminate = true;
+    } finally {
+      if (fh) await fh.close().catch(() => {});
+    }
+  }
+  return { forked: false, indeterminate };
+}
+
 function isCodexSessionCursorPath(filePath) {
   if (typeof filePath !== "string") return false;
   const normalized = filePath.replace(/\\/g, "/");

package/src/lib/codex-config.js

@@ -55,12 +55,12 @@ async function restoreNotify({ configPath, notifyOriginalPath, expectedNotify })
   const originalNotify = Array.isArray(original?.notify) ? original.notify : null;
   const currentNotify = extractNotify(text);
 
-  if (expectedNotify && !arraysEqual(currentNotify, expectedNotify)) {
-    return { restored: false, skippedReason: "current-not-managed" };
+  if (!originalNotify && expectedNotify && currentNotify == null) {
+    return { restored: false, skippedReason: "no-backup-not-installed" };
   }
 
-  if (!originalNotify && expectedNotify && !arraysEqual(currentNotify, expectedNotify)) {
-    return { restored: false, skippedReason: "no-backup-not-installed" };
+  if (expectedNotify && !arraysEqual(currentNotify, expectedNotify)) {
+    return { restored: false, skippedReason: "current-not-managed" };
   }
 
   const updated = originalNotify ? setNotify(text, originalNotify) : removeNotify(text);
@@ -161,15 +161,16 @@ function extractNotify(text) {
   const lines = text.split(/\r?\n/);
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
+    if (isTomlTableHeader(line)) break;
     const m = line.match(/^\s*notify\s*=\s*(.*)\s*$/);
     if (!m) continue;
 
     const rhs = (m[1] || "").trim();
     const literal = readTomlArrayLiteral(lines, i, rhs);
-    if (!literal) continue;
+    if (!literal) return null;
 
     const parsed = parseTomlStringArray(literal);
-    if (parsed) return parsed;
+    return parsed;
   }
   return null;
 }
@@ -182,6 +183,14 @@ function setNotify(text, notifyCmd) {
   let replaced = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
+    if (isTomlTableHeader(line)) {
+      if (!replaced) {
+        out.push(notifyLine);
+        replaced = true;
+      }
+      out.push(...lines.slice(i));
+      break;
+    }
     const m = line.match(/^\s*notify\s*=\s*(.*)\s*$/);
     if (m) {
       if (!replaced) {
@@ -190,7 +199,7 @@ function setNotify(text, notifyCmd) {
       }
 
       const rhs = (m[1] || "").trim();
-      i = findTomlArrayBlockEnd(lines, i, rhs);
+      i = findNotifyBlockEnd(lines, i, rhs);
       continue;
     }
     out.push(line);
@@ -211,10 +220,14 @@ function removeNotify(text) {
   const out = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
+    if (isTomlTableHeader(line)) {
+      out.push(...lines.slice(i));
+      break;
+    }
     const m = line.match(/^\s*notify\s*=\s*(.*)\s*$/);
     if (m) {
       const rhs = (m[1] || "").trim();
-      i = findTomlArrayBlockEnd(lines, i, rhs);
+      i = findNotifyBlockEnd(lines, i, rhs);
       continue;
     }
     out.push(line);
@@ -225,45 +238,78 @@ function removeNotify(text) {
 function parseTomlStringArray(rhs) {
   // Minimal parser for TOML basic/literal string arrays.
   if (!rhs.startsWith("[") || !rhs.endsWith("]")) return null;
-  const inner = rhs.slice(1, -1).trim();
-  if (!inner) return [];
 
   const parts = [];
-  let current = "";
-  let inString = false;
-  let quote = null;
-  for (let i = 0; i < inner.length; i++) {
-    const ch = inner[i];
-    if (!inString) {
-      if (ch === '"' || ch === "'") {
-        inString = true;
-        quote = ch;
-        current = "";
+  let i = 1;
+  let expectValue = true;
+
+  function skipSpaceAndComments() {
+    while (i < rhs.length) {
+      const ch = rhs[i];
+      if (/\s/.test(ch)) {
+        i += 1;
+        continue;
       }
-      continue;
+      if (ch === "#") {
+        while (i < rhs.length && rhs[i] !== "\n") i += 1;
+        continue;
+      }
+      break;
     }
-    if (ch === quote) {
-      parts.push(current);
-      inString = false;
-      quote = null;
-      continue;
+  }
+
+  function parseString() {
+    const quote = rhs[i];
+    if (quote !== '"' && quote !== "'") return null;
+    i += 1;
+    let value = "";
+    while (i < rhs.length) {
+      const ch = rhs[i];
+      if (ch === quote) {
+        i += 1;
+        return value;
+      }
+      if (ch === "\n" || ch === "\r") return null;
+      if (quote === '"' && ch === "\\") {
+        if (i + 1 >= rhs.length) return null;
+        const next = rhs[i + 1];
+        if (next === "b") value += "\b";
+        else if (next === "t") value += "\t";
+        else if (next === "n") value += "\n";
+        else if (next === "f") value += "\f";
+        else if (next === "r") value += "\r";
+        else if (next === '"' || next === "\\" || next === "/") value += next;
+        else return null;
+        i += 2;
+        continue;
+      }
+      value += ch;
+      i += 1;
+    }
+    return null;
+  }
+
+  while (i < rhs.length) {
+    skipSpaceAndComments();
+    if (rhs[i] === "]") {
+      i += 1;
+      skipSpaceAndComments();
+      return i === rhs.length ? parts : null;
     }
-    if (quote === '"' && ch === "\\") {
-      if (i + 1 >= inner.length) return null;
-      const next = inner[++i];
-      if (next === "b") current += "\b";
-      else if (next === "t") current += "\t";
-      else if (next === "n") current += "\n";
-      else if (next === "f") current += "\f";
-      else if (next === "r") current += "\r";
-      else if (next === '"' || next === "\\" || next === "/") current += next;
-      else return null;
+    if (!expectValue) {
+      if (rhs[i] !== ",") return null;
+      i += 1;
+      expectValue = true;
       continue;
     }
-    current += ch;
+
+    const value = parseString();
+    if (value == null) return null;
+    parts.push(value);
+    expectValue = false;
   }
 
-  return parts.length > 0 ? parts : null;
+  return null;
 }
 
 function formatTomlStringArray(arr) {
@@ -278,6 +324,7 @@ function readTomlArrayLiteral(lines, startIndex, rhs) {
   let quote = null;
   let depth = 0;
   let sawOpen = false;
+  let invalid = false;
 
   function scanChunk(chunk) {
     for (let i = 0; i < chunk.length; i++) {
@@ -295,7 +342,10 @@ function readTomlArrayLiteral(lines, startIndex, rhs) {
         }
         if (ch === "]") {
           depth -= 1;
-          if (sawOpen && depth === 0) return i;
+          if (sawOpen && depth === 0) {
+            if (!isTomlArrayTrailer(chunk.slice(i + 1))) invalid = true;
+            return i;
+          }
         }
         continue;
       }
@@ -305,6 +355,10 @@ function readTomlArrayLiteral(lines, startIndex, rhs) {
         continue;
       }
       if (quote === '"' && ch === "\\") {
+        if (i + 1 >= chunk.length) {
+          invalid = true;
+          return -1;
+        }
         i += 1;
       }
     }
@@ -313,11 +367,13 @@ function readTomlArrayLiteral(lines, startIndex, rhs) {
 
   const parts = [first];
   let endPos = scanChunk(first);
+  if (invalid) return null;
   if (endPos !== -1) return first.slice(0, endPos + 1).trim();
 
   for (let j = startIndex + 1; j < lines.length; j++) {
     const line = lines[j];
     endPos = scanChunk(line);
+    if (invalid) return null;
     if (endPos !== -1) {
       parts.push(line.slice(0, endPos + 1));
       return parts.join("\n").trim();
@@ -336,6 +392,7 @@ function findTomlArrayBlockEnd(lines, startIndex, rhs) {
   let quote = null;
   let depth = 0;
   let sawOpen = false;
+  let invalid = false;
 
   function scanChunk(chunk) {
     for (let i = 0; i < chunk.length; i++) {
@@ -353,7 +410,10 @@ function findTomlArrayBlockEnd(lines, startIndex, rhs) {
         }
         if (ch === "]") {
           depth -= 1;
-          if (sawOpen && depth === 0) return true;
+          if (sawOpen && depth === 0) {
+            if (!isTomlArrayTrailer(chunk.slice(i + 1))) invalid = true;
+            return true;
+          }
         }
         continue;
       }
@@ -363,6 +423,10 @@ function findTomlArrayBlockEnd(lines, startIndex, rhs) {
         continue;
       }
       if (quote === '"' && ch === "\\") {
+        if (i + 1 >= chunk.length) {
+          invalid = true;
+          return false;
+        }
         i += 1;
       }
     }
@@ -370,12 +434,43 @@ function findTomlArrayBlockEnd(lines, startIndex, rhs) {
   }
 
   if (scanChunk(first)) return startIndex;
+  if (invalid) return startIndex;
   for (let j = startIndex + 1; j < lines.length; j++) {
     if (scanChunk(lines[j])) return j;
+    if (invalid) return startIndex;
   }
   return startIndex;
 }
 
+function findNotifyBlockEnd(lines, startIndex, rhs) {
+  const endIndex = findTomlArrayBlockEnd(lines, startIndex, rhs);
+  const literal = readTomlArrayLiteral(lines, startIndex, rhs);
+  if (
+    endIndex !== startIndex ||
+    !rhs.trim().startsWith("[") ||
+    (literal && parseTomlStringArray(literal))
+  ) {
+    return endIndex;
+  }
+
+  for (let j = startIndex + 1; j < lines.length; j++) {
+    if (isTopLevelTomlBoundary(lines[j])) return j - 1;
+  }
+  return lines.length - 1;
+}
+
+function isTomlTableHeader(line) {
+  return /^\s*\[\[?[^\]]+\]\]?\s*(?:#.*)?$/.test(line);
+}
+
+function isTopLevelTomlBoundary(line) {
+  return /^\s*(?:\[\[?[^\]]+\]\]?|(?:[A-Za-z0-9_-]+|"[^"]+"|'[^']+')(?:\s*\.\s*(?:[A-Za-z0-9_-]+|"[^"]+"|'[^']+'))*\s*=)/.test(line);
+}
+
+function isTomlArrayTrailer(text) {
+  return /^\s*(?:#.*)?$/.test(text);
+}
+
 function arraysEqual(a, b) {
   if (!Array.isArray(a) || !Array.isArray(b)) return false;
   if (a.length !== b.length) return false;