Add failover channel events to activity journal

test/server/activity-journal-service.test.js

@@ -128,6 +128,53 @@ test('journal exposes a latched write failure until a later append succeeds', (t
   assert.equal(service.page().storage.status, 'ready');
 });
 
+
+test('schema version 1 keeps legacy recovery and accepts per-channel health events', (t) => {
+  const filePath = fixture(t);
+  const occurredAt = '2026-08-19T09:00:00.000Z';
+  fs.writeFileSync(filePath, JSON.stringify({
+    schemaVersion: 1,
+    events: [{
+      id: '00000000-0000-4000-8000-000000000001',
+      occurredAt,
+      type: 'failover.recovered',
+      severity: 'info',
+      source: 'failover',
+      dedupeKey: null,
+      data: { role: 'primary', reason: 'primary-recovered' },
+    }],
+  }));
+  let clock = new Date('2026-08-19T10:00:00.000Z');
+  const service = createActivityJournalService({ filePath, now: () => clock });
+  const inputs = [
+    ['failover.primary_unavailable', 'primary', 'warning', 'probe-failed'],
+    ['failover.primary_recovered', 'primary', 'info', 'probe-recovered'],
+    ['failover.reserve_unavailable', 'reserve', 'warning', 'probe-failed'],
+    ['failover.reserve_recovered', 'reserve', 'info', 'probe-recovered'],
+  ];
+  for (const [type, role, severity, reason] of inputs) {
+    service.append({
+      type,
+      severity,
+      source: 'failover',
+      dedupeKey: null,
+      data: { role, reason },
+    });
+    clock = new Date(clock.getTime() + 1_000);
+  }
+
+  const page = service.page();
+  assert.deepEqual(page.events.map(({ type }) => type), [
+    'failover.reserve_recovered',
+    'failover.reserve_unavailable',
+    'failover.primary_recovered',
+    'failover.primary_unavailable',
+    'failover.recovered',
+  ]);
+  assert.deepEqual(page.events.at(-1).data, { role: 'primary', reason: 'primary-recovered' });
+  assert.equal(page.retentionDays, 30);
+  assert.equal(JSON.parse(fs.readFileSync(filePath, 'utf8')).schemaVersion, 1);
+});
 test('journal page parser rejects malformed wire data and strips unknown event fields', (t) => {
   const service = createActivityJournalService({ filePath: fixture(t) });
   service.append(event('wire'));

test/server/failover-service.test.js

@@ -282,7 +282,9 @@ test('runtime rollback restores the role from applied truth even while disabled'
 
 test('an in-flight observation is discarded after failover is disabled', async () => {
   const pending = [];
+  const events = [];
   const testHarness = harness(serviceState(), {
+    onEvent: (event) => events.push(event),
     dataplane: {
       checkConfig: async () => ({}),
       runFailoverProbe: (role) => new Promise((resolve) => pending.push({ role, resolve })),
@@ -302,6 +304,7 @@ test('an in-flight observation is discarded after failover is disabled', async (
   assert.equal(testHarness.read().failoverPolicy.enabled, false);
   assert.equal(testHarness.calls.some((call) => call.startsWith('select:reserve')), false);
   assert.deepEqual(testHarness.calls.filter((call) => call.startsWith('activity:')), ['activity:true', 'activity:true', 'activity:false']);
+  assert.deepEqual(events.filter(({ type }) => /_(?:unavailable|recovered)$/.test(type)), []);
 });
 
 test('one channel probe failure does not erase the other channel health', async () => {
@@ -595,7 +598,7 @@ test('disabling on reserve preserves it as the next ordinary single-channel targ
   assert.equal(testHarness.service.snapshot().activation, 'passive-loaded');
 });
 
-test('significant health states append once without logging every observation', async () => {
+test('background health transitions cover both channels without duplicate observations', async () => {
   let clock = 0;
   const health = { primary: 'unavailable', reserve: 'available' };
   const events = [];
@@ -611,23 +614,153 @@ test('significant health states append once without logging every observation',
       readFailoverActivity: async () => ({ activity: { state: 'quiet', observedAt: new Date(clock).toISOString() } }),
     },
   });
+  const healthEvents = () => events.filter(({ type }) => /_(?:unavailable|recovered)$/.test(type));
+  const round = async () => {
+    await testHarness.service.runRound();
+    clock += 1_000;
+  };
+
   await testHarness.service.reconcile();
+  await round();
+  await round();
+  health.reserve = 'unavailable';
+  await round();
+  await round();
+  health.primary = 'available';
+  await round();
+  health.primary = 'unavailable';
+  await round();
+  health.reserve = 'available';
+  await round();
+  health.reserve = 'unavailable';
+  await round();
+
+  assert.deepEqual(healthEvents().map(({ type, severity, data }) => ({ type, severity, role: data.role })), [
+    { type: 'failover.primary_unavailable', severity: 'warning', role: 'primary' },
+    { type: 'failover.reserve_unavailable', severity: 'warning', role: 'reserve' },
+    { type: 'failover.primary_recovered', severity: 'info', role: 'primary' },
+    { type: 'failover.primary_unavailable', severity: 'warning', role: 'primary' },
+    { type: 'failover.reserve_recovered', severity: 'info', role: 'reserve' },
+    { type: 'failover.reserve_unavailable', severity: 'warning', role: 'reserve' },
+  ]);
+  assert.ok(healthEvents().every(({ dedupeKey }) => dedupeKey === null));
+  assert.equal(events.some(({ type }) => type === 'failover.recovered'), false);
+  assert.equal(events.filter(({ type }) => type === 'failover.both_unhealthy').length, 3);
+});
+
+test('activity read failure does not hide completed channel health transitions', async () => {
+  const events = [];
+  const testHarness = harness(serviceState(), {
+    onEvent: (event) => events.push(event),
+    dataplane: {
+      checkConfig: async () => ({}),
+      runFailoverProbe: async (role) => ({
+        vpn: { sites: [{ status: role === 'primary' ? 'unavailable' : 'available' }] },
+      }),
+      readFailoverSelector: async () => ({ role: 'primary' }),
+      selectFailoverRole: async (role) => ({ role }),
+      setFailoverActivityEnabled: async () => {},
+      readFailoverActivity: async () => { throw new Error('activity unavailable'); },
+    },
+  });
+
+  await testHarness.service.reconcile();
+  await assert.rejects(testHarness.service.runRound(), /activity unavailable/);
+  assert.deepEqual(events.map(({ type }) => type), ['failover.primary_unavailable']);
+  assert.equal(events.some(({ type }) => ['failover.waiting_for_idle', 'failover.both_unhealthy', 'failover.switched', 'failover.switch_failed'].includes(type)), false);
+});
+
+test('manual check does not strand monitoring behind a stale background round', async () => {
+  const pending = [];
+  const scheduled = [];
+  let holdBackground = true;
+  let probeCalls = 0;
+  const testHarness = harness(serviceState(), {
+    scheduler: {
+      setTimeout: (callback) => {
+        scheduled.push(callback);
+        return { unref() {} };
+      },
+      clearTimeout: () => {},
+    },
+    dataplane: {
+      checkConfig: async () => ({}),
+      runFailoverProbe: (role) => {
+        probeCalls += 1;
+        if (holdBackground) {
+          return new Promise((resolve) => pending.push({ role, resolve }));
+        }
+        return Promise.resolve({ vpn: { sites: [{ status: 'available' }] } });
+      },
+      readFailoverSelector: async () => ({ role: 'primary' }),
+      selectFailoverRole: async (role) => ({ role }),
+      setFailoverActivityEnabled: async () => {},
+      readFailoverActivity: async () => ({ activity: { state: 'quiet', observedAt: new Date().toISOString() } }),
+    },
+  });
+
+  await testHarness.service.reconcile();
+  const oldRound = testHarness.service.runRound();
+  await new Promise(setImmediate);
+  assert.equal(pending.length, 4);
+  holdBackground = false;
+  await testHarness.service.checkNow();
+  assert.equal(probeCalls, 8);
+  scheduled.at(-1)();
+  for (const probe of pending) {
+    probe.resolve({ vpn: { sites: [{ status: 'available' }] } });
+  }
+  await oldRound;
+  await new Promise(setImmediate);
+  await new Promise(setImmediate);
+  assert.equal(probeCalls, 12);
+});
+
+test('manual and background checks share channel transition memory', async () => {
+  const health = { primary: 'available', reserve: 'available' };
+  const events = [];
+  const testHarness = harness(serviceState(), {
+    onEvent: (event) => events.push(event),
+    dataplane: {
+      checkConfig: async () => ({}),
+      runFailoverProbe: async (role) => ({ vpn: { sites: [{ status: health[role] }] } }),
+      readFailoverSelector: async () => ({ role: 'primary' }),
+      selectFailoverRole: async (role) => ({ role }),
+      setFailoverActivityEnabled: async () => {},
+      readFailoverActivity: async () => ({ activity: { state: 'quiet', observedAt: new Date().toISOString() } }),
+    },
+  });
+  const healthTypes = () => events
+    .filter(({ type }) => /_(?:unavailable|recovered)$/.test(type))
+    .map(({ type }) => type);
+
+  await testHarness.service.reconcile();
+  await testHarness.service.checkNow();
+  assert.deepEqual(healthTypes(), []);
+  health.primary = 'unavailable';
+  await testHarness.service.checkNow();
+  assert.deepEqual(healthTypes(), ['failover.primary_unavailable']);
   await testHarness.service.runRound();
-  clock = 30_000;
+  assert.deepEqual(healthTypes(), ['failover.primary_unavailable']);
+  health.primary = 'available';
+  await testHarness.service.checkNow();
+  health.primary = 'unavailable';
   await testHarness.service.runRound();
   health.reserve = 'unavailable';
-  clock = 31_000;
+  await testHarness.service.checkNow();
   await testHarness.service.runRound();
-  clock = 32_000;
-  await testHarness.service.runRound();
-  health.primary = 'available';
-  clock = 33_000;
+  health.reserve = 'available';
+  await testHarness.service.checkNow();
+  health.reserve = 'unavailable';
   await testHarness.service.runRound();
 
-  assert.deepEqual(events.map(({ type }) => type), [
-    'failover.waiting_for_idle',
-    'failover.both_unhealthy',
-    'failover.recovered',
+  assert.deepEqual(healthTypes(), [
+    'failover.primary_unavailable',
+    'failover.primary_recovered',
+    'failover.primary_unavailable',
+    'failover.reserve_unavailable',
+    'failover.reserve_recovered',
+    'failover.reserve_unavailable',
   ]);
 });
 

test/web/activity-journal-feature-contract.test.js

@@ -16,22 +16,40 @@ test('journal is the last Gateway-only drawer and refreshes whenever it opens',
   assert.match(feature, /assertActivityJournalPage\(await loadPage\(cursor\)\)/);
 });
 
-test('journal presents 30-day grouped history with refresh, pagination and stable states', () => {
+test('journal presents a semantic responsive timeline with stable states', () => {
   assert.match(feature, /Важные события хранятся 30 дней/);
   assert.match(feature, /Сегодня[\s\S]*Вчера/);
   assert.match(feature, /Обновить журнал/);
-  assert.match(feature, /M5 8V4m0 4h4/);
   assert.match(feature, /Показать ещё/);
   assert.match(feature, /Журнал временно недоступен[\s\S]*Повторить/);
   assert.match(styles, /\.client-journal-skeleton/);
-  assert.match(styles, /@media \(prefers-reduced-motion: reduce\)/);
   assert.match(feature, /compactActivityJournalEvents\(events\)/);
   assert.match(model, /Подписки обновлялись без ошибок/);
+  assert.match(feature, /<ol>[\s\S]*<li[\s\S]*<time dateTime=\{event\.occurredAt\}/);
   assert.match(feature, /data-event-type=\{event\.type\}[\s\S]*data-severity=\{event\.severity\}[\s\S]*data-target-role=/);
-  assert.match(styles, /\.client-journal-event::before \{[^}]*background: var\(--client-journal-tone\); \}/);
+
+  const rowRule = styles.match(/\.client-journal-groups li \{[^}]*\}/)?.[0] || '';
+  const lineRule = styles.match(/\.client-journal-groups ol::before \{[^}]*\}/)?.[0] || '';
+  const dotRule = styles.match(/\.client-journal-event::before \{[^}]*\}/)?.[0] || '';
+  assert.match(rowRule, /min-height: 58px/);
+  assert.match(rowRule, /grid-template-columns: 52px minmax\(0, 1fr\)/);
+  assert.doesNotMatch(rowRule, /border-top/);
+  assert.match(lineRule, /width: 1px/);
+  assert.match(lineRule, /inset: 0 auto 0 -8px/);
+  assert.match(lineRule, /background: color-mix\(in oklch, var\(--client-border\) 48%, transparent\)/);
+  assert.doesNotMatch(lineRule, /--client-journal-tone|animation|transition/);
+  assert.match(dotRule, /width: 8px/);
+  assert.match(dotRule, /height: 8px/);
+  assert.match(dotRule, /border-radius: 50%/);
+  assert.match(dotRule, /inset: 15px auto auto -11\.5px/);
+  assert.match(dotRule, /background: var\(--client-journal-tone\)/);
+  assert.doesNotMatch(dotRule, /animation|transition/);
+
   assert.match(styles, /\.client-journal-event \.client-journal-time span \{ color: var\(--client-journal-tone\); \}/);
-  assert.match(styles, /\[data-event-type='subscription\.refreshed'\][\s\S]*\[data-event-type='failover\.recovered'\][\s\S]*--client-journal-tone: var\(--harbor-connect\)/);
-  assert.match(styles, /\[data-target-role='reserve'\] \{ --client-journal-tone: var\(--harbor-gateway\); \}/);
-  assert.match(styles, /\[data-event-type='failover\.waiting_for_idle'\][\s\S]*\[data-severity='warning'\] \{ --client-journal-tone: oklch\(0\.68 0\.14 72\); \}/);
+  assert.match(styles, /\[data-event-type='failover\.primary_recovered'\][\s\S]*--client-journal-tone: var\(--harbor-connect\)/);
+  assert.match(styles, /\[data-event-type='failover\.reserve_recovered'\][\s\S]*--client-journal-tone: var\(--harbor-gateway\)/);
+  assert.match(styles, /\[data-severity='warning'\] \{ --client-journal-tone: oklch\(0\.68 0\.14 72\); \}/);
   assert.match(styles, /\[data-severity='error'\] \{ --client-journal-tone: oklch\(0\.68 0\.15 28\); \}/);
+  assert.match(styles, /@media \(max-width: 560px\) \{[\s\S]*?\.client-journal-groups li \{[^}]*grid-template-columns: 1fr;[^}]*\}[\s\S]*?\.client-journal-time \{[^}]*display: flex;/);
+  assert.match(styles, /@media \(prefers-reduced-motion: reduce\) \{[^}]*animation: none;/);
 });

test/web/activity-journal-model.test.js

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 
 import {
+  activityJournalEventCopy,
   compactActivityJournalEvents,
   refreshStreakCopy,
 } from '../../.test-dist/src/web/features/activity-journal/activityJournalModel.js';
@@ -75,3 +76,31 @@ test('one-profile streak names the profile and keeps the latest event identity',
     '15 мин всё хорошо · 2 обновления · Дом',
   ]);
 });
+
+test('channel health events use role-specific copy without raw reason codes', () => {
+  const cases = [
+    ['failover.primary_unavailable', 'primary', 'probe-failed', ['Основной канал недоступен', 'Проверки канала не пройдены']],
+    ['failover.reserve_unavailable', 'reserve', 'probe-failed', ['Резервный канал недоступен', 'Проверки канала не пройдены']],
+    ['failover.primary_recovered', 'primary', 'probe-recovered', ['Основной канал восстановлен', 'Проверки канала снова проходят успешно']],
+    ['failover.reserve_recovered', 'reserve', 'probe-recovered', ['Резервный канал восстановлен', 'Проверки канала снова проходят успешно']],
+    ['failover.recovered', 'primary', 'primary-recovered', ['Основной канал восстановлен', 'Проверки канала снова проходят успешно']],
+    ['failover.recovered', 'reserve', 'reserve-recovered', ['Резервный канал восстановлен', 'Проверки канала снова проходят успешно']],
+  ];
+
+  for (const [type, role, reason, copy] of cases) {
+    const item = event(`event-${type}-${role}`, '2026-08-27T10:00:00.000Z', type, { role, reason });
+    assert.deepEqual(activityJournalEventCopy(item), copy);
+    assert.equal(activityJournalEventCopy(item).join(' ').includes(reason), false);
+  }
+
+  const switched = event('switched', '2026-08-27T10:01:00.000Z', 'failover.switched', {
+    fromRole: 'primary',
+    toRole: 'reserve',
+    reason: 'failure-window',
+  });
+  assert.deepEqual(activityJournalEventCopy(switched), [
+    'Новые соединения переключены',
+    'primary → reserve',
+  ]);
+  assert.equal(activityJournalEventCopy(switched).join(' ').includes('failure-window'), false);
+});

test/web/style-boundaries.test.js

@@ -39,25 +39,25 @@ const expectedImports = [
 const sha256 = (value) => crypto.createHash('sha256').update(value).digest('hex');
 const acceptedLedger = {
   counts: {
-    cascadeEdges: 1054,
+    cascadeEdges: 1058,
     customProperties: 111,
-    declarations: 4123,
+    declarations: 4131,
     important: 0,
     keyframes: 50,
     media: 17,
-    rules: 1113,
+    rules: 1114,
     variableReferences: 1055,
   },
   hashes: {
-    cascadeEdges: 'c3b2ebc3f49891437122b19af5e9a42e7db11a311ecb4c2c76446c1541fe1023',
-    customProperties: '14fb162f1c6d754e69dd355fefb1a3a192a191324468f85d7a5d811665ce35b4',
-    declarations: '37b2f9f3ace795a826ad5eca6e6c4ba98ab6bb893aac87938bdeef826c383d63',
+    cascadeEdges: '77b6f34b3bc07b326f477cc436926fb9c4c573e5da9bba840c9bf937542b4488',
+    customProperties: '42f9fa9f2caaab6e5d90ae7d224563355822fa270083ea3496cfe2caaaea50bf',
+    declarations: 'ac1ac026d0c9d656fde9b28f78faea216a518a44bd2856b2005041f7cb4abd11',
     duplicateKeyframes: '4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945',
     duplicateSelectors: '8982145dba05b33bf1c93b2d54cfbe76305b276ff3c657aa020144016ada5848',
     keyframes: 'af4b9ae18d070fd2462a9b050293f3821bf5017c6e7cc53bbe18dc826f0fe3b9',
-    ruleDeclarationSequences: '24377c2c29079886b62124688c2f858142913247426728c9b81f4b0a79e559e6',
-    selectors: '0b7624b5064d514a267e9bb45c40c445ce10f3e6998a34af7e1b604e4c0445b9',
-    variableReferences: '56dbfff5943b1ddd09d31b9d6699ff6680d07e5e562285f5f8268cc7566dca59',
+    ruleDeclarationSequences: '885efbe91db2ecb739f3c5aa42023576a849d28e639a1694ad13ed696bef77c5',
+    selectors: 'fbd8ac40b8d543a29b7140db906d1a3f7fc16a64ebbb380f358629f78657456a',
+    variableReferences: '70cef326744490dbb615e83457cd42b81b6f2322b0e93e4de6661d53db97e14b',
     witnesses: 'e9f8c6e640c19375635847dc064edd6752a8216c6acd3c2aad6ffd18c1a4aaa2',
   },
 };
@@ -408,8 +408,8 @@ test('main owns one public stylesheet and the regrouped production CSS is determ
   assert.equal((main.match(/import ['"][^'"]+\.css['"]/g) || []).length, 1);
 
   const assets = fs.readdirSync(path.join(root, 'dist/assets')).filter((file) => file.endsWith('.css'));
-  assert.deepEqual(assets, ['index-Dng8HPUW.css']);
+  assert.deepEqual(assets, ['index-3s7H6Y0X.css']);
   const built = fs.readFileSync(path.join(root, 'dist/assets', assets[0]));
-  assert.equal(built.byteLength, 157518);
-  assert.equal(sha256(built), '4fbc6c3e73a497101cacc456b580c6c4b8a58a44870856689719f2ada5b92bd7');
+  assert.equal(built.byteLength, 157874);
+  assert.equal(sha256(built), '99b874016cac6f1b617cd21d5a7ac957f491d8926fe78e8ba514d9313255488f');
 });