From 287f05d0249a4961618ae723dfe03f62e2a0c0f8 Mon Sep 17 00:00:00 2001
From: Tomek Zebrowski <zebrowski.tomek@gmail.com>
Date: Mon, 24 Aug 2026 21:53:48 +0200
Subject: [PATCH] feat: pick WOT filter signals by vehicle tag

The WOT quick-filter always isolated the 175tbi channel set and
preselected every signal in the log. On a 2.0gme file that meant
filtering ~80 unrelated channels (oil level, fuel level, ...) to
then isolate names that ECU never reports.

MathDefinition gains autoEnableSignalsByTag, keyed on LoadedFile.tags
(seeded from the Drive appProperties a file was loaded with). The WOT
formula now maps '175tbi' to the existing list and '2.0gme' to its own,
with the 175tbi set kept as the tag-agnostic default so untagged logs
behave as before.

MathChannelsService resolves the list (resolveAutoEnableSignals), the
sources to preselect (resolveBatchSources) and the tag that matched
(resolveAutoEnableTag). Signal names are matched case/whitespace-
insensitively against the file's own names, like the acceleration
extra-curve lookup, since the GME dictionary's newline-split
descriptions come through with irregular spacing; an exact-name lookup
would silently isolate nothing. A tagged file whose channels are all
absent falls back to selecting everything rather than leaving Create
disabled with an empty selection.

The modal notes which tag drove the preselection under both the
"Signals to Filter" and "Signals to Show" fields.
---
 CLAUDE.md                                     |  1 +
 .../math-channel-modal/math-channel-modal.css | 10 ++
 .../math-channel-modal.html                   | 12 ++-
 .../math-channel-modal/math-channel-modal.ts  | 35 ++++++-
 src/app/core/math-channels.service.spec.ts    | 97 +++++++++++++++++++
 src/app/core/math-channels.service.ts         | 93 +++++++++++++++++-
 src/app/core/math-definitions.ts              | 63 +++++++++---
 7 files changed, 290 insertions(+), 21 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 17560ee..2e58740 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -10,6 +10,7 @@
 - **Tooling Reliance:** Do not act as a syntax linter or formatter. Rely on ESLint, Stylelint, and Prettier (see Commands below) and CI to catch formatting/lint issues.
 - **Never amend commits:** Always create a new commit instead of `git commit --amend`, even for a small immediate follow-up fix (e.g. a lint/format correction) to a commit made moments earlier. This holds regardless of whether the original commit has been pushed.
 - **Run Prettier before committing:** Run `npx prettier --write` on changed files (or `npm run format`) before creating a commit, so CI's Prettier check doesn't fail on avoidable formatting issues.
+- **Keep the commit title short:** The subject line must fit the conventional-commit standard of ~50 characters and never exceed 72 — GitHub truncates longer titles in the commits list and PR view, so the point of the change gets cut off. Recent history here has titles that are far too long; don't copy them. Write `<type>: <short imperative summary>` and put the detail in the commit body, not the title.
 - **No AI co-author trailer:** Never add a `Co-Authored-By: Claude ...` (or similar AI-attribution) line to commit messages.
 - **Branch from a local ref, not a remote-tracking ref:** Never run `git checkout -b <branch> origin/main` (or `origin/<anything>`) to create a feature branch. Passing a remote-tracking ref as the start-point makes git auto-set that branch's upstream to it (`branch.autoSetupMerge`), so a later push with no explicit destination silently targets `main`/that remote branch instead of creating `origin/<branch>` — this already caused a rejected push straight to `main`. Instead branch from local `main` (`git checkout -b <branch> main`, after `git fetch`/`git pull` if it needs to be current) so no upstream is auto-configured, and only set one explicitly via `git push -u origin <branch>` when actually pushing.
 
diff --git a/src/app/analyzer/math-channel-modal/math-channel-modal.css b/src/app/analyzer/math-channel-modal/math-channel-modal.css
index a3953f2..968647d 100644
--- a/src/app/analyzer/math-channel-modal/math-channel-modal.css
+++ b/src/app/analyzer/math-channel-modal/math-channel-modal.css
@@ -69,3 +69,13 @@
   font-size: 0.85em;
   padding: 6px 4px;
 }
+
+.math-tag-note {
+  font-size: 0.8rem;
+  color: var(--text-secondary);
+  margin: 6px 0 0;
+}
+
+.math-tag-note strong {
+  color: var(--accent, var(--text-primary));
+}
diff --git a/src/app/analyzer/math-channel-modal/math-channel-modal.html b/src/app/analyzer/math-channel-modal/math-channel-modal.html
index d27063d..97a9cf8 100644
--- a/src/app/analyzer/math-channel-modal/math-channel-modal.html
+++ b/src/app/analyzer/math-channel-modal/math-channel-modal.html
@@ -91,7 +91,12 @@ <h2>Create Math Channel</h2>
           <span class="math-signal-no-results">No signals match.</span>
           }
         </div>
-        } @else if (input.isConstant && input.options) {
+        @if (appliedTag(); as tag) {
+        <p class="math-tag-note">
+          Preselected {{ selectedSources().length }} signal(s) for the
+          <strong>{{ tag }}</strong> tag.
+        </p>
+        } } @else if (input.isConstant && input.options) {
         <select
           class="template-select"
           [value]="inputValues()[inputIdx] ?? ''"
@@ -184,6 +189,11 @@ <h2>Create Math Channel</h2>
           [disabled]="!isolateEnabled()"
           (input)="autoEnableText.set($any($event.target).value)"
         />
+        @if (appliedTag(); as tag) {
+        <p class="math-tag-note">
+          Isolate list for the <strong>{{ tag }}</strong> tag.
+        </p>
+        }
       </div>
       } @if (errorMessage(); as error) {
       <div class="math-error-msg">{{ error }}</div>
diff --git a/src/app/analyzer/math-channel-modal/math-channel-modal.ts b/src/app/analyzer/math-channel-modal/math-channel-modal.ts
index 93b67a2..2130cc1 100644
--- a/src/app/analyzer/math-channel-modal/math-channel-modal.ts
+++ b/src/app/analyzer/math-channel-modal/math-channel-modal.ts
@@ -52,6 +52,8 @@ export class MathChannelModal {
   protected readonly smoothWindow = signal(5);
   protected readonly isolateEnabled = signal(false);
   protected readonly autoEnableText = signal('');
+  /** The file tag whose channel set drove the current preselection (e.g. '2.0gme'), or null when the tag-agnostic default was used -- shown next to the affected fields. */
+  protected readonly appliedTag = signal<string | null>(null);
   protected readonly errorMessage = signal<string | null>(null);
 
   protected readonly selectedDefinition = computed<MathDefinition | undefined>(
@@ -106,14 +108,20 @@ export class MathChannelModal {
       this.channelName.set('');
       this.isolateEnabled.set(false);
       this.autoEnableText.set('');
+      this.appliedTag.set(null);
       return;
     }
 
+    const file = this.currentFile();
+
+    // Tag-aware: a '2.0gme' log isolates a different channel set than a
+    // 175tbi one (see MathChannelsService.resolveAutoEnableSignals).
+    const autoEnable = this.mathChannels.resolveAutoEnableSignals(def, file);
+    this.appliedTag.set(this.mathChannels.resolveAutoEnableTag(def, file));
     this.channelName.set(def.isBatch ? '[Auto Generated]' : def.name);
-    this.isolateEnabled.set(!!def.autoEnableSignals?.length);
-    this.autoEnableText.set(def.autoEnableSignals?.join(', ') ?? '');
+    this.isolateEnabled.set(autoEnable.length > 0);
+    this.autoEnableText.set(autoEnable.join(', '));
 
-    const file = this.currentFile();
     const values: Partial<Record<number, string>> = {};
     def.inputs.forEach((input, idx) => {
       if (input.isConstant) {
@@ -143,7 +151,9 @@ export class MathChannelModal {
     this.inputValues.set(values);
 
     if (def.preSelectAllSources && file) {
-      this.selectedSources.set([...file.availableSignals]);
+      this.selectedSources.set(
+        this.mathChannels.resolveBatchSources(def, file)
+      );
     }
   }
 
@@ -242,12 +252,26 @@ export class MathChannelModal {
             refreshedFile.availableSignals,
             false
           );
+          // Matched case/whitespace-insensitively against the file's actual
+          // signal names, like AccelerationService.captureExtraCurves: the
+          // same channel comes through with slightly different spacing
+          // depending on the source dictionary, and an exact-name-only
+          // lookup would silently isolate nothing.
+          const normalize = (s: string) =>
+            s.trim().toLowerCase().replace(/\s+/g, ' ');
+          const byNormalizedName = new Map(
+            refreshedFile.availableSignals.map((sig) => [normalize(sig), sig])
+          );
           this.autoEnableText()
             .split(',')
             .map((s) => s.trim())
             .filter(Boolean)
             .forEach((sig) =>
-              this.appState.setSignalVisible(fileIndex, sig, true)
+              this.appState.setSignalVisible(
+                fileIndex,
+                byNormalizedName.get(normalize(sig)) ?? sig,
+                true
+              )
             );
         }
       }
@@ -273,6 +297,7 @@ export class MathChannelModal {
     this.smoothWindow.set(5);
     this.isolateEnabled.set(false);
     this.autoEnableText.set('');
+    this.appliedTag.set(null);
     this.errorMessage.set(null);
 
     // untracked: this runs from an effect keyed on isModalOpen() — reading
diff --git a/src/app/core/math-channels.service.spec.ts b/src/app/core/math-channels.service.spec.ts
index 2747fa1..3dd95d2 100644
--- a/src/app/core/math-channels.service.spec.ts
+++ b/src/app/core/math-channels.service.spec.ts
@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it } from 'vitest';
 import { AppStateService } from './app-state.service';
 import { DbManagerService } from './db-manager.service';
 import { EventBusService } from './event-bus.service';
+import { MATH_DEFINITIONS } from './math-definitions';
 import { MathChannelsService } from './math-channels.service';
 import { EVENTS, LoadedFile, SignalPoint } from './models';
 import { SignalRegistryService } from './signal-registry.service';
@@ -315,6 +316,102 @@ describe('MathChannelsService', () => {
     });
   });
 
+  describe('resolveAutoEnableSignals', () => {
+    const wotFilter = MATH_DEFINITIONS.find(
+      (d) => d.id === 'gas_pedal_filter_batch'
+    )!;
+
+    it('falls back to the tag-agnostic list for an untagged file', () => {
+      const resolved = service.resolveAutoEnableSignals(
+        wotFilter,
+        makeFile({})
+      );
+      expect(resolved).toBe(wotFilter.autoEnableSignals);
+    });
+
+    it("returns the 2.0gme channel set for a file tagged '2.0gme'", () => {
+      const resolved = service.resolveAutoEnableSignals(
+        wotFilter,
+        makeFile({}, { tags: ['2.0gme', 'Bluetooth'] })
+      );
+      expect(resolved).toBe(wotFilter.autoEnableSignalsByTag!['2.0gme']);
+      expect(resolved).toContain('Math: Filtered: Measured Boost Pressure');
+      expect(resolved).not.toContain('Math: Filtered: Throttle position');
+    });
+
+    it("returns the 175tbi channel set -- same as the default -- for a file tagged '175tbi'", () => {
+      const resolved = service.resolveAutoEnableSignals(
+        wotFilter,
+        makeFile({}, { tags: ['175tbi'] })
+      );
+      expect(resolved).toEqual(wotFilter.autoEnableSignals);
+      expect(resolved).toContain('Math: Filtered: Over Boost Measured');
+    });
+
+    it('returns an empty list for a definition with no auto-enable set, and tolerates a missing file', () => {
+      const plain = MATH_DEFINITIONS.find((d) => d.id === 'multiply_const')!;
+      expect(service.resolveAutoEnableSignals(plain, makeFile({}))).toEqual([]);
+      expect(service.resolveAutoEnableSignals(wotFilter, undefined)).toBe(
+        wotFilter.autoEnableSignals
+      );
+    });
+  });
+
+  describe('resolveBatchSources', () => {
+    const wotFilter = MATH_DEFINITIONS.find(
+      (d) => d.id === 'gas_pedal_filter_batch'
+    )!;
+
+    it('pre-selects every signal for an untagged file', () => {
+      const file = makeFile({ 'Engine Oil Level': [], 'Fuel Level': [] });
+      expect(service.resolveBatchSources(wotFilter, file)).toEqual(
+        file.availableSignals
+      );
+    });
+
+    it("narrows to the tagged channel set's own sources for a '2.0gme' file", () => {
+      const file = makeFile(
+        {
+          'Engine Oil Level': [],
+          'Fuel Level': [],
+          'Engine Speed': [],
+          // Irregular spacing, as the GME dictionary's newline-split
+          // descriptions come through -- still has to match.
+          'Gas Pedal  Position': [],
+          'Measured Boost Pressure': [],
+        },
+        { tags: ['2.0gme'] }
+      );
+      expect(service.resolveBatchSources(wotFilter, file)).toEqual([
+        'Measured Boost Pressure',
+        'Gas Pedal  Position',
+        'Engine Speed',
+      ]);
+    });
+
+    it("narrows a '175tbi' file to its own channel set too", () => {
+      const file = makeFile(
+        {
+          'Engine Oil Level': [],
+          'Over Boost Measured': [],
+          'Throttle position': [],
+        },
+        { tags: ['175tbi'] }
+      );
+      expect(service.resolveBatchSources(wotFilter, file)).toEqual([
+        'Over Boost Measured',
+        'Throttle position',
+      ]);
+    });
+
+    it('falls back to every signal when the tagged set matches nothing in the file', () => {
+      const file = makeFile({ 'Engine Oil Level': [] }, { tags: ['2.0gme'] });
+      expect(service.resolveBatchSources(wotFilter, file)).toEqual(
+        file.availableSignals
+      );
+    });
+  });
+
   describe('executeAutoMath', () => {
     it('auto-creates GPS distance/speed and trip cost channels when the raw signals exist', () => {
       appState.addFile(
diff --git a/src/app/core/math-channels.service.ts b/src/app/core/math-channels.service.ts
index 94681de..225d386 100644
--- a/src/app/core/math-channels.service.ts
+++ b/src/app/core/math-channels.service.ts
@@ -9,6 +9,9 @@ import {
 import { ActionLogEvent, EVENTS, LoadedFile, SignalPoint } from './models';
 import { SignalRegistryService } from './signal-registry.service';
 
+/** Name prefix `createBatchChannels` gives each generated channel (`Math: ` is added by finalizeChannel) -- also how `resolveBatchSources` maps an auto-enable entry back to its source signal. */
+const BATCH_CHANNEL_PREFIX = 'Math: Filtered: ';
+
 export interface CreateChannelOptions {
   smooth?: boolean;
   smoothWindow?: number;
@@ -113,6 +116,94 @@ export class MathChannelsService {
     return MATH_DEFINITIONS.find((d) => d.id === id);
   }
 
+  /**
+   * The signals a formula's "isolate on chart" step should re-enable for
+   * `file`, honouring `autoEnableSignalsByTag` (see MathDefinition): the WOT
+   * quick-filter isolates a different channel set on a '2.0gme' log than on a
+   * '175tbi' one, since the two ECUs name the same measurements differently.
+   * Falls back to the tag-agnostic `autoEnableSignals` when the file carries
+   * none of the mapped tags (or has no tags at all).
+   */
+  resolveAutoEnableSignals(
+    definition: MathDefinition,
+    file: LoadedFile | undefined
+  ): string[] {
+    return (
+      this.tagSpecificAutoEnableSignals(definition, file) ??
+      definition.autoEnableSignals ??
+      []
+    );
+  }
+
+  /**
+   * Which source signals a `preSelectAllSources` batch formula should start
+   * with for `file`. When a tag-specific auto-enable list applies, only the
+   * sources behind that list are pre-selected: a 2.0gme log carries ~80
+   * channels, and filtering every one of them just to isolate nine afterwards
+   * is wasted work (and a wall of checkboxes to undo by hand). Everything
+   * else -- no tag-specific list, or none of its signals present in this file
+   * -- keeps the "select everything" default.
+   */
+  resolveBatchSources(
+    definition: MathDefinition,
+    file: LoadedFile | undefined
+  ): string[] {
+    const available = file?.availableSignals ?? [];
+    const tagged = this.tagSpecificAutoEnableSignals(definition, file);
+    if (!tagged) return [...available];
+
+    // Same case/whitespace-insensitive matching as AccelerationService's
+    // extra-curve lookup -- the same channel can come through with slightly
+    // different spacing depending on the source dictionary.
+    const normalize = (s: string) =>
+      s.trim().toLowerCase().replace(/\s+/g, ' ');
+    const byNormalizedName = new Map(
+      available.map((sig) => [normalize(sig), sig])
+    );
+
+    const sources: string[] = [];
+    for (const entry of tagged) {
+      const match = byNormalizedName.get(
+        normalize(
+          entry.startsWith(BATCH_CHANNEL_PREFIX)
+            ? entry.slice(BATCH_CHANNEL_PREFIX.length)
+            : entry
+        )
+      );
+      if (match && !sources.includes(match)) sources.push(match);
+    }
+    return sources.length > 0 ? sources : [...available];
+  }
+
+  /** Which of `file`'s tags drove `resolveAutoEnableSignals`/`resolveBatchSources`, or null when neither used a tag-specific list -- surfaced in the modal so the preselection isn't unexplained. */
+  resolveAutoEnableTag(
+    definition: MathDefinition,
+    file: LoadedFile | undefined
+  ): string | null {
+    return this.matchTagEntry(definition, file)?.[0] ?? null;
+  }
+
+  private tagSpecificAutoEnableSignals(
+    definition: MathDefinition,
+    file: LoadedFile | undefined
+  ): string[] | null {
+    return this.matchTagEntry(definition, file)?.[1] ?? null;
+  }
+
+  /** The `autoEnableSignalsByTag` entry matching one of `file`'s tags (first match wins), or null when none applies. */
+  private matchTagEntry(
+    definition: MathDefinition,
+    file: LoadedFile | undefined
+  ): [string, string[]] | null {
+    const tags = file?.tags ?? [];
+    for (const entry of Object.entries(
+      definition.autoEnableSignalsByTag ?? {}
+    )) {
+      if (tags.includes(entry[0])) return entry;
+    }
+    return null;
+  }
+
   createChannel(
     fileIndex: number,
     formulaId: string,
@@ -188,7 +279,7 @@ export class MathChannelsService {
 
     sources.forEach((src) => {
       const singleInputs = [src, ...restInputs];
-      const name = `Filtered: ${src}`;
+      const name = `${BATCH_CHANNEL_PREFIX}${src}`;
       const createdName = this.createChannel(
         fileIndex,
         targetId,
diff --git a/src/app/core/math-definitions.ts b/src/app/core/math-definitions.ts
index 4b338cd..bddad5a 100644
--- a/src/app/core/math-definitions.ts
+++ b/src/app/core/math-definitions.ts
@@ -31,6 +31,15 @@ export interface MathDefinition {
   singleVariantId?: string;
   preSelectAllSources?: boolean;
   autoEnableSignals?: string[];
+  /**
+   * Per-vehicle-tag overrides for `autoEnableSignals`, keyed by a
+   * `LoadedFile.tags` entry (seeded from the Drive appProperties the file was
+   * loaded with). The 175tbi and 2.0gme ECUs expose the same measurements
+   * under different channel names, so the WOT quick-filter's isolate list has
+   * to follow the loaded file's tag; the first matching tag wins, and
+   * `autoEnableSignals` stays the default for files carrying none of them.
+   */
+  autoEnableSignalsByTag?: Record<string, string[]>;
   autoLoad?: MathAutoLoad;
   formula?: (values: number[]) => number;
   customProcess?: (
@@ -39,6 +48,41 @@ export interface MathDefinition {
   ) => SignalPoint[];
 }
 
+/**
+ * The WOT quick-filter's isolate list per vehicle tag: the 175tbi and 2.0gme
+ * ECUs report the same measurements under different channel names, so the
+ * `gas_pedal_filter_batch` formula picks its set from the loaded file's
+ * `LoadedFile.tags` (see MathChannelsService.resolveAutoEnableSignals). The
+ * 175tbi set doubles as the tag-agnostic default, so an untagged log keeps
+ * behaving as it did before the tag split.
+ */
+const WOT_FILTER_SIGNALS_175TBI = [
+  'Math: Filtered: Intake Manifold Pressure Measured',
+  'Math: Filtered: Intake Manifold Pressure Target',
+  'Math: Filtered: Spark Advance',
+  'Math: Filtered: Air Mass Flow Target',
+  'Math: Filtered: Air Mass Flow Measured',
+  'Math: Filtered: Over Boost Measured',
+  'Math: Filtered: Over Boost Target',
+  'Math: Filtered: Engine Rpm',
+  'Math: Filtered: Engine Speed',
+  'Math: Filtered: 02 Sensor Integrator',
+  'Math: Filtered: Throttle position',
+  'Math: Filtered: Gas Pedal Position',
+];
+
+const WOT_FILTER_SIGNALS_20GME = [
+  'Math: Filtered: Measured Boost Pressure',
+  'Math: Filtered: Measured Engine Torque',
+  'Math: Filtered: Measured Intake Pressure',
+  'Math: Filtered: Target Intake Pressure',
+  'Math: Filtered: Gas Pedal Position',
+  'Math: Filtered: Engine Speed',
+  'Math: Filtered: Calculated Air Flow Rate',
+  'Math: Filtered: Spark Advance',
+  'Math: Filtered: Lambda Upstream',
+];
+
 /** Port of legacy/src/mathdefinitions.js — the derived-signal formula catalog. */
 export const MATH_DEFINITIONS: MathDefinition[] = [
   {
@@ -797,20 +841,11 @@ export const MATH_DEFINITIONS: MathDefinition[] = [
     isBatch: true,
     singleVariantId: 'filtered_single',
     preSelectAllSources: true,
-    autoEnableSignals: [
-      'Math: Filtered: Intake Manifold Pressure Measured',
-      'Math: Filtered: Intake Manifold Pressure Target',
-      'Math: Filtered: Spark Advance',
-      'Math: Filtered: Air Mass Flow Target',
-      'Math: Filtered: Air Mass Flow Measured',
-      'Math: Filtered: Over Boost Measured',
-      'Math: Filtered: Over Boost Target',
-      'Math: Filtered: Engine Rpm',
-      'Math: Filtered: Engine Speed',
-      'Math: Filtered: 02 Sensor Integrator',
-      'Math: Filtered: Throttle position',
-      'Math: Filtered: Gas Pedal Position',
-    ],
+    autoEnableSignals: WOT_FILTER_SIGNALS_175TBI,
+    autoEnableSignalsByTag: {
+      '175tbi': WOT_FILTER_SIGNALS_175TBI,
+      '2.0gme': WOT_FILTER_SIGNALS_20GME,
+    },
     inputs: [
       { name: 'sources', label: 'Signals to Filter', isMulti: true },
       {