fix(v2): derive track selection from appliesTo field, not track flag

The deriveCategorySelection function was incorrectly using the track flag
as the basis for track selection. When no categories had track=true, it
fell back to including ALL categories in track selection, even if they
only had appliesTo: ['observation'].

This fix changes the logic to respect the appliesTo field as the
authoritative source for track selection:

- Track selection now includes only categories where appliesTo includes 'track'
- For observation-only payloads (all categories with appliesTo: ['observation']),
  track selection is correctly empty
- The track flag is now just a hint; appliesTo is the source of truth

Changes:
- Removed fallback logic that defaulted to all categories
- Changed filter to check c.definition.appliesTo.includes('track')
- Added comprehensive test coverage (6 test cases)

Tests verify:
- Observation-only categories are excluded from track selection
- Track selection respects appliesTo field regardless of track flag
- Mixed payloads handle both observation and track categories correctly

Author: luandro

src/services/comapeocatBuilder.ts

@@ -271,14 +271,11 @@ function normalizeTags(tags: any, categoryId: string): Record<string, unknown> {
 
 function deriveCategorySelection(categories: MappedCategory[]) {
   const observation = categories.map((c) => c.id);
-  const track = categories.filter((c) => c.track).map((c) => c.id);
-
-  // If no categories have track=true, default to including all categories in track selection
-  // This allows observation-only configs but provides sensible default for track
-  if (track.length === 0) {
-    console.warn('No categories marked with track=true, defaulting all categories to track selection');
-    return { observation, track: observation };
-  }
+  // Track selection should only include categories whose appliesTo includes 'track'
+  // The track flag is just a hint, but appliesTo is the authoritative field
+  const track = categories
+    .filter((c) => c.definition.appliesTo.includes('track'))
+    .map((c) => c.id);
 
   return { observation, track };
 }

src/tests/unit/services/comapeocatBuilder.test.ts

@@ -231,6 +231,123 @@ describe('sanitizePathComponent security', () => {
   });
 });
 
+describe('deriveCategorySelection', () => {
+  it('includes only categories with appliesTo: track in track selection', () => {
+    const categories = [
+      {
+        id: 'obs-only',
+        definition: { name: 'Observation Only', appliesTo: ['observation'], tags: {}, fields: [] },
+        track: false,
+      },
+      {
+        id: 'track-enabled',
+        definition: { name: 'Track Enabled', appliesTo: ['observation', 'track'], tags: {}, fields: [] },
+        track: false,
+      },
+    ];
+
+    const selection = __test__.deriveCategorySelection(categories);
+
+    expect(selection.observation).toEqual(['obs-only', 'track-enabled']);
+    expect(selection.track).toEqual(['track-enabled']);
+  });
+
+  it('returns empty track selection when no categories have appliesTo: track', () => {
+    const categories = [
+      {
+        id: 'obs-1',
+        definition: { name: 'Observation 1', appliesTo: ['observation'], tags: {}, fields: [] },
+        track: false,
+      },
+      {
+        id: 'obs-2',
+        definition: { name: 'Observation 2', appliesTo: ['observation'], tags: {}, fields: [] },
+        track: false,
+      },
+    ];
+
+    const selection = __test__.deriveCategorySelection(categories);
+
+    expect(selection.observation).toEqual(['obs-1', 'obs-2']);
+    expect(selection.track).toEqual([]);
+  });
+
+  it('includes category with track=true in track selection when appliesTo includes track', () => {
+    const categories = [
+      {
+        id: 'track-cat',
+        definition: { name: 'Track Category', appliesTo: ['observation', 'track'], tags: {}, fields: [] },
+        track: true,
+      },
+    ];
+
+    const selection = __test__.deriveCategorySelection(categories);
+
+    expect(selection.observation).toEqual(['track-cat']);
+    expect(selection.track).toEqual(['track-cat']);
+  });
+
+  it('does not include observation-only category in track selection even with track=true', () => {
+    const categories = [
+      {
+        id: 'obs-only',
+        definition: { name: 'Observation Only', appliesTo: ['observation'], tags: {}, fields: [] },
+        track: true, // track flag should be ignored if appliesTo doesn't include 'track'
+      },
+    ];
+
+    const selection = __test__.deriveCategorySelection(categories);
+
+    expect(selection.observation).toEqual(['obs-only']);
+    expect(selection.track).toEqual([]);
+  });
+
+  it('includes track-only category in track selection', () => {
+    const categories = [
+      {
+        id: 'track-only',
+        definition: { name: 'Track Only', appliesTo: ['track'], tags: {}, fields: [] },
+        track: false,
+      },
+    ];
+
+    const selection = __test__.deriveCategorySelection(categories);
+
+    expect(selection.observation).toEqual(['track-only']);
+    expect(selection.track).toEqual(['track-only']);
+  });
+
+  it('handles mixed categories correctly', () => {
+    const categories = [
+      {
+        id: 'obs-1',
+        definition: { name: 'Observation 1', appliesTo: ['observation'], tags: {}, fields: [] },
+        track: false,
+      },
+      {
+        id: 'both-1',
+        definition: { name: 'Both 1', appliesTo: ['observation', 'track'], tags: {}, fields: [] },
+        track: false,
+      },
+      {
+        id: 'obs-2',
+        definition: { name: 'Observation 2', appliesTo: ['observation'], tags: {}, fields: [] },
+        track: true, // Should not affect track selection
+      },
+      {
+        id: 'both-2',
+        definition: { name: 'Both 2', appliesTo: ['track', 'observation'], tags: {}, fields: [] },
+        track: true,
+      },
+    ];
+
+    const selection = __test__.deriveCategorySelection(categories);
+
+    expect(selection.observation).toEqual(['obs-1', 'both-1', 'obs-2', 'both-2']);
+    expect(selection.track).toEqual(['both-1', 'both-2']);
+  });
+});
+
 function createBasePayload(options?: { fieldTypeOverride?: string }): BuildRequestV2 {
   return {
     metadata: { name: 'test', version: '1.0.0' },