diff --git a/components/player/Queue.vue b/components/player/Queue.vue
index 8f891e85..8911a0ef 100644
--- a/components/player/Queue.vue
+++ b/components/player/Queue.vue
@@ -147,9 +147,15 @@
 
       <div v-else-if="activeTab === 'schedule' && hasSchedule" class="space-y-1">
         <template v-if="program.length">
+          <template v-for="(item, index) in program" :key="programKey(item, index)">
+            <PlayerScheduleGap
+              v-if="scheduleGap?.insertIndex === index"
+              :timestamp="scheduleNow"
+              :start-time="gapStartTime(scheduleGap.insertIndex)"
+              :next-title="scheduleGap.nextTitle"
+              :next-start-time="scheduleGap.nextStartTime"
+            />
           <div
-            v-for="(item, index) in program"
-            :key="programKey(item, index)"
             :data-program-index="index"
             class="relative grid grid-cols-[72px_minmax(0,1fr)] gap-3 overflow-hidden rounded-xl px-2.5 py-2.5 transition"
             :class="
@@ -163,6 +169,14 @@
               class="absolute inset-y-2 left-0 w-0.5 rounded-full bg-rose-500"
               aria-hidden="true"
             ></span>
+            <div v-if="isCurrentProgram(item, index) && scheduleIsReference"
+              class="pointer-events-none absolute inset-x-2 bottom-0 h-1 rounded-full bg-rose-500/15"
+              aria-hidden="true">
+              <div data-schedule-time-progress class="relative h-full rounded-full bg-rose-500 transition-[width] duration-1000 ease-linear"
+                :style="{ width: (programmeProgress(item) ?? 0) + '%' }">
+                <span class="absolute right-0 top-1/2 h-2.5 w-2.5 translate-x-1/2 -translate-y-1/2 rounded-full border-2 border-[var(--radio-surface)] bg-rose-500 shadow-sm"></span>
+              </div>
+            </div>
 
             <div
               class="rounded-lg bg-[var(--radio-surface)] px-2 py-1.5 text-xs font-semibold tabular-nums text-[var(--radio-text)] ring-1 ring-inset ring-[var(--radio-border)]"
@@ -193,8 +207,21 @@
               >
                 {{ item.description }}
               </p>
+              <p v-if="isCurrentProgram(item, index) && scheduleIsReference"
+                data-schedule-clock role="timer"
+                class="mt-1 text-[11px] font-semibold tabular-nums text-rose-700 dark:text-rose-300">
+                {{ $t('panel.schedule_now_marker') }} · {{ formattedScheduleNow }}
+              </p>
             </div>
           </div>
+          </template>
+          <PlayerScheduleGap
+            v-if="scheduleGap?.insertIndex === program.length"
+            :timestamp="scheduleNow"
+            :start-time="gapStartTime(scheduleGap.insertIndex)"
+            :next-title="scheduleGap.nextTitle"
+            :next-start-time="scheduleGap.nextStartTime"
+          />
         </template>
 
         <template v-else-if="playlist.length">
@@ -259,7 +286,7 @@
 import type { RadioStationOption } from "~/types/radio";
 import { normalizeStationQuery } from "~/utils/station-search.mjs";
 import { stationCountryKey, queueCountryKey } from "~/utils/queue-station-country.mjs";
-import { schedulePosition } from "~/utils/station-schedule.mjs";
+import { schedulePosition, referenceScheduleGap, scheduleTimelineProgress } from "~/utils/station-schedule.mjs";
 
 const dayjs = useDayjs();
 const { t } = useI18n();
@@ -344,6 +371,20 @@ const manuallyBrowsingSchedule = ref(false);
 const schedulePositionNow = computed(() =>
   schedulePosition(props.program, scheduleNow.value, props.scheduleIsReference),
 );
+const scheduleGap = computed(() => props.scheduleIsReference
+  ? referenceScheduleGap(props.program, scheduleNow.value)
+  : null);
+// Only a known interval has a meaningful progress percentage.
+const gapStartTime = (index: number): number | null =>
+  index > 0 ? props.program[index - 1]?.endTime ?? null : null;
+const programmeProgress = (item: ProgramItem): number | null =>
+  scheduleTimelineProgress(item.startTime, item.endTime, scheduleNow.value);
+const vietnamSecondsFormatter = new Intl.DateTimeFormat('en-GB', {
+  timeZone: 'Asia/Ho_Chi_Minh',
+  hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+});
+const formattedScheduleNow = computed(() =>
+  vietnamSecondsFormatter.format(new Date(scheduleNow.value * 1000)));
 
 // Move just the INNER queue scroller: scrollIntoView() would move the entire
 // mobile slideover/page and could hide the fixed player/header.
@@ -355,9 +396,11 @@ const jumpToSchedulePosition = async () => {
   if (generation !== scrollGeneration || activeTab.value !== 'schedule' || !props.visible) return;
   const container = scheduleScrollContainer.value;
   const index = schedulePositionNow.value.scrollIndex;
-  const row = index < 0 ? null : container?.querySelector<HTMLElement>(
-    `[data-program-index="${index}"]`,
-  );
+  const row = scheduleGap.value
+    ? container?.querySelector<HTMLElement>('[data-schedule-now]')
+    : index < 0 ? null : container?.querySelector<HTMLElement>(
+      `[data-program-index="${index}"]`,
+    );
   if (!container || !row || container.clientHeight === 0) return;
   const containerRect = container.getBoundingClientRect();
   const rowRect = row.getBoundingClientRect();
@@ -399,18 +442,31 @@ watch(
 
 // Update the highlight at a programme boundary. Follow it only if the visitor
 // has not manually scrolled away. No polling/scrolling every animation frame.
-watch(() => schedulePositionNow.value.scrollIndex, (next, previous) => {
-  if (next !== previous && activeTab.value === 'schedule' && props.visible && !manuallyBrowsingSchedule.value) {
-    void jumpToSchedulePosition();
-  }
-}, { flush: 'post' });
+watch(
+  [
+    () => schedulePositionNow.value.scrollIndex,
+    () => schedulePositionNow.value.currentIndex,
+    () => scheduleGap.value?.insertIndex,
+  ],
+  (next, previous) => {
+    if (next.some((value, index) => value !== previous?.[index])
+      && activeTab.value === 'schedule' && props.visible && !manuallyBrowsingSchedule.value) {
+      void jumpToSchedulePosition();
+    }
+  },
+  { flush: 'post' },
+);
 
 let scheduleClockTimer: ReturnType<typeof setInterval> | null = null;
 onMounted(() => {
   scheduleNow.value = Math.floor(Date.now() / 1000);
   scheduleClockTimer = setInterval(() => {
-    scheduleNow.value = Math.floor(Date.now() / 1000);
-  }, 15_000);
+    // Clock and the timeline fill move once per second. Only update the
+    // visible reference guide; real-time provider EPG is unaffected.
+    if (activeTab.value === 'schedule' && props.visible && props.scheduleIsReference) {
+      scheduleNow.value = Math.floor(Date.now() / 1000);
+    }
+  }, 1_000);
   if (activeTab.value === 'schedule' && props.visible) void jumpToSchedulePosition();
 });
 onBeforeUnmount(() => {
diff --git a/components/player/ScheduleGap.vue b/components/player/ScheduleGap.vue
new file mode 100644
index 00000000..d96ca6d2
--- /dev/null
+++ b/components/player/ScheduleGap.vue
@@ -0,0 +1,56 @@
+<template>
+  <div
+    data-schedule-now
+    role="note"
+    class="relative my-2 rounded-xl border border-rose-500/25 bg-rose-500/[0.06] px-3 py-3"
+  >
+    <div class="mb-2 flex items-center gap-2">
+      <span data-schedule-clock role="timer" class="shrink-0 rounded-md bg-rose-500 px-2 py-1 text-xs font-bold tabular-nums text-white">
+        {{ formattedNow }}
+      </span>
+      <div class="relative h-1 min-w-0 flex-1 rounded-full bg-rose-500/15" aria-hidden="true">
+        <div data-schedule-time-progress class="h-full rounded-full bg-rose-500 transition-[width] duration-1000 ease-linear"
+          :style="{ width: timelineProgress === null ? '0%' : timelineProgress + '%' }"></div>
+        <span v-if="timelineProgress !== null"
+          class="absolute top-1/2 h-2.5 w-2.5 -translate-x-1/2 -translate-y-1/2 rounded-full border-2 border-[var(--radio-surface)] bg-rose-500 shadow-sm transition-[left] duration-1000 ease-linear"
+          :style="{ left: timelineProgress + '%' }"></span>
+      </div>
+      <span class="shrink-0 text-[10px] font-semibold text-rose-700 dark:text-rose-300">
+        {{ $t('panel.schedule_now_marker') }}
+      </span>
+    </div>
+    <p class="text-xs font-semibold leading-5 text-[var(--radio-text)]">
+      {{ $t('panel.schedule_gap_unknown') }}
+    </p>
+    <p v-if="nextStartTime && nextTitle" class="mt-1 text-xs leading-5 text-[var(--radio-text-muted)]">
+      {{ $t('panel.schedule_gap_next', { title: nextTitle, time: formattedNext }) }}
+    </p>
+    <p v-else class="mt-1 text-xs leading-5 text-[var(--radio-text-muted)]">
+      {{ $t('panel.schedule_gap_no_next') }}
+    </p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { scheduleTimelineProgress } from '~/utils/station-schedule.mjs';
+const props = withDefaults(defineProps<{
+  timestamp: number;
+  startTime?: number | null;
+  nextTitle?: string;
+  nextStartTime?: number | null;
+}>(), { startTime: null, nextTitle: '', nextStartTime: null });
+
+// Only used for broadcaster reference guides, all in Vietnam's UTC+7 zone.
+const formatter = new Intl.DateTimeFormat('en-GB', {
+  timeZone: 'Asia/Ho_Chi_Minh', hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+});
+const formattedNow = computed(() => formatter.format(new Date(props.timestamp * 1000)));
+const formattedNext = computed(() => props.nextStartTime
+  ? new Intl.DateTimeFormat('en-GB', {
+      timeZone: 'Asia/Ho_Chi_Minh', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+    }).format(new Date(props.nextStartTime * 1000))
+  : '');
+const timelineProgress = computed(() => scheduleTimelineProgress(
+  props.startTime, props.nextStartTime, props.timestamp,
+));
+</script>
diff --git a/docs/VIETNAM_SCHEDULES.md b/docs/VIETNAM_SCHEDULES.md
index 8ff02f85..ea8f2a67 100644
--- a/docs/VIETNAM_SCHEDULES.md
+++ b/docs/VIETNAM_SCHEDULES.md
@@ -46,3 +46,18 @@ not make requests while SSR prerenders thousands of pages.
   caching, and a fallback when the broadcaster fails.
 - Run `npm test`; the dedicated checks are in
   `tests/vietnam-schedules.test.mjs`.
+
+## Gaps between listed programmes
+
+Reference schedules can omit a period (for example VOV Giao thông TP.HCM
+**16:15–16:30**). The player now renders a neutral **current-time marker**
+inside the gap, with Vietnam's clock and the next listed programme/time.
+The absence of EPG metadata must **not** be represented as the radio going
+off-air, a confirmed broadcast title, or a technical stream failure.
+
+The queue auto-centers the marker on opening Schedule, while preserving
+manual scrolling until the user asks to jump back. At the next valid programme
+boundary, the synthetic gap marker disappears and the real schedule row takes
+over. See `referenceScheduleGap` in `utils/station-schedule.mjs` and the
+regressions in `tests/station-schedule.test.mjs` and
+`tests/browser/schedule-autoscroll.spec.mjs`.
diff --git a/lang/en-US.json b/lang/en-US.json
index 3819f47b..20178d75 100644
--- a/lang/en-US.json
+++ b/lang/en-US.json
@@ -149,6 +149,10 @@
     "category": "Category",
     "schedule": "Schedule",
     "schedule_jump_to_now": "Jump to current time",
+    "schedule_now_marker": "Now",
+    "schedule_gap_unknown": "No programme details are listed for this time.",
+    "schedule_gap_next": "Up next (scheduled): {title} · {time}",
+    "schedule_gap_no_next": "No further programme is listed in today's reference guide.",
     "schedule_reference_note": "Reference programme times from the broadcaster. Daily programming may change; check the official guide for the latest schedule.",
     "schedule_official_note": "Official broadcast schedule source.",
     "schedule_official_link": "View official schedule",
diff --git a/lang/fr-FR.json b/lang/fr-FR.json
index cd652200..3a5fe832 100644
--- a/lang/fr-FR.json
+++ b/lang/fr-FR.json
@@ -149,6 +149,10 @@
     "category": "Catégorie",
     "schedule": "Programme",
     "schedule_jump_to_now": "Aller à l'heure actuelle",
+    "schedule_now_marker": "Maintenant",
+    "schedule_gap_unknown": "Aucune émission n'est indiquée pour ce créneau.",
+    "schedule_gap_next": "À suivre (selon le programme) : {title} · {time}",
+    "schedule_gap_no_next": "Aucune autre émission n'est indiquée dans le programme du jour.",
     "schedule_reference_note": "Horaires indicatifs de la station, susceptibles de changer selon le jour. Consultez le programme officiel.",
     "schedule_official_note": "Source officielle des programmes.",
     "schedule_official_link": "Voir le programme officiel",
diff --git a/lang/ja-JP.json b/lang/ja-JP.json
index f3a42cac..0ddbbddb 100644
--- a/lang/ja-JP.json
+++ b/lang/ja-JP.json
@@ -149,6 +149,10 @@
     "category": "カテゴリー",
     "schedule": "スケジュール",
     "schedule_jump_to_now": "現在の時間帯へ",
+    "schedule_now_marker": "現在",
+    "schedule_gap_unknown": "この時間帯の番組情報は掲載されていません。",
+    "schedule_gap_next": "次の予定番組：{title} · {time}",
+    "schedule_gap_no_next": "今日の参考番組表に次の番組は掲載されていません。",
     "schedule_reference_note": "放送局の参考番組表です。日によって変更される場合があります。最新情報は公式番組表をご確認ください。",
     "schedule_official_note": "放送局の公式番組表。",
     "schedule_official_link": "公式番組表を見る",
diff --git a/lang/ru-RU.json b/lang/ru-RU.json
index 4f582b16..799c7430 100644
--- a/lang/ru-RU.json
+++ b/lang/ru-RU.json
@@ -149,6 +149,10 @@
     "category": "Категория",
     "schedule": "Программа передач",
     "schedule_jump_to_now": "К текущему времени",
+    "schedule_now_marker": "Сейчас",
+    "schedule_gap_unknown": "Для этого времени программа передач не указана.",
+    "schedule_gap_next": "Далее по расписанию: {title} · {time}",
+    "schedule_gap_no_next": "В сегодняшней справочной программе больше нет передач.",
     "schedule_reference_note": "Ориентировочные часы программ по данным вещателя. Расписание может меняться; актуальные данные — на официальном сайте.",
     "schedule_official_note": "Официальный источник программы передач.",
     "schedule_official_link": "Открыть официальное расписание",
diff --git a/lang/vi-VN.json b/lang/vi-VN.json
index fd358c60..053b103d 100644
--- a/lang/vi-VN.json
+++ b/lang/vi-VN.json
@@ -149,6 +149,10 @@
     "category": "Thể Loại",
     "schedule": "Lịch phát sóng",
     "schedule_jump_to_now": "Đến khung giờ hiện tại",
+    "schedule_now_marker": "Bây giờ",
+    "schedule_gap_unknown": "Chưa có thông tin chương trình cho thời điểm này.",
+    "schedule_gap_next": "Tiếp theo (theo lịch): {title} · {time}",
+    "schedule_gap_no_next": "Không có chương trình tiếp theo trong lịch tham khảo hôm nay.",
     "schedule_reference_note": "Khung giờ tham khảo từ đài phát thanh; chương trình có thể thay đổi theo ngày. Xem lịch chính thức để kiểm tra mới nhất.",
     "schedule_official_note": "Nguồn lịch chính thức của đài phát thanh.",
     "schedule_official_link": "Xem lịch chính thức",
diff --git a/lang/zh-CN.json b/lang/zh-CN.json
index 82d3bdc9..fb68d6c0 100644
--- a/lang/zh-CN.json
+++ b/lang/zh-CN.json
@@ -149,6 +149,10 @@
     "category": "分类",
     "schedule": "节目表",
     "schedule_jump_to_now": "跳转到当前时段",
+    "schedule_now_marker": "现在",
+    "schedule_gap_unknown": "该时段暂无节目表信息。",
+    "schedule_gap_next": "接下来（节目表）：{title} · {time}",
+    "schedule_gap_no_next": "今日参考节目表中没有后续节目。",
     "schedule_reference_note": "以下为广播台提供的参考时段，节目可能因日期而变化。请查看官方节目表获取最新信息。",
     "schedule_official_note": "广播台官方节目表来源。",
     "schedule_official_link": "查看官方节目表",
diff --git a/lang/zh-TW.json b/lang/zh-TW.json
index 55655eda..869f443c 100644
--- a/lang/zh-TW.json
+++ b/lang/zh-TW.json
@@ -149,6 +149,10 @@
     "category": "類別",
     "schedule": "節目表",
     "schedule_jump_to_now": "跳至目前時段",
+    "schedule_now_marker": "現在",
+    "schedule_gap_unknown": "此時段尚無節目表資訊。",
+    "schedule_gap_next": "接下來（節目表）：{title} · {time}",
+    "schedule_gap_no_next": "今日參考節目表中沒有後續節目。",
     "schedule_reference_note": "以下為電台提供的參考時段，節目可能依日期調整。請查看官方節目表取得最新資訊。",
     "schedule_official_note": "電台官方節目表來源。",
     "schedule_official_link": "查看官方節目表",
diff --git a/tests/browser/schedule-autoscroll.spec.mjs b/tests/browser/schedule-autoscroll.spec.mjs
index 5060fcd0..91f19d42 100644
--- a/tests/browser/schedule-autoscroll.spec.mjs
+++ b/tests/browser/schedule-autoscroll.spec.mjs
@@ -42,21 +42,85 @@ test('VOV Giao thông guide opens at the current Vietnam programme, not the firs
   await expect.poll(() => scroll.evaluate(element => element.scrollTop)).toBeGreaterThan(40);
 });
 
-test('guide in a gap focuses the next slot without labeling it as live', async ({ page }) => {
+test('16:29 ICT shows a Now marker in an unlisted interval, then switches to 16:30 programme', async ({ page }) => {
   await page.setViewportSize({ width: 1536, height: 900 });
-  // 08:20 UTC = 15:20; instead test 11:30 ICT gap between 11:00 and 12:30.
-  await page.clock.install({ time: new Date('2026-10-14T04:30:00Z') });
+  // 09:29 UTC = 16:29 ICT, exactly between FM91 (ends 16:15)
+  // and Giờ cao điểm chiều (starts 16:30).
+  await page.clock.install({ time: new Date('2026-10-14T09:29:00Z') });
   await page.goto('/asia/viet-nam/vov-gt-hcm');
   await page.waitForFunction(() => Boolean(document.querySelector('#__nuxt')?.__vue_app__));
   await page.locator('.radio-player-dock').getByRole('button', { name: 'Channels & schedule' }).click();
   await queue(page).getByRole('tab', { name: /Schedule/ }).click();
 
-  const nextSlot = queue(page).locator('[data-program-index="5"]'); // 12:30
-  await expect(nextSlot).toBeVisible();
-  await expect.poll(() => nextSlot.evaluate(row => {
+  const marker = queue(page).locator('[data-schedule-now]');
+  await expect(marker).toBeVisible();
+  await expect(marker).toContainText('16:29');
+  await expect(marker).toContainText('No programme details are listed for this time');
+  await expect(marker).toContainText('Giờ cao điểm chiều');
+  await expect(marker).toContainText('16:30');
+  await expect.poll(() => marker.evaluate(row => {
     const viewport = row.closest('.radio-scrollbar').getBoundingClientRect();
     const box = row.getBoundingClientRect();
     return box.top >= viewport.top && box.bottom <= viewport.bottom;
   })).toBe(true);
+
+  const nextSlot = queue(page).locator('[data-program-index="7"]');
   await expect(nextSlot.locator('.absolute.inset-y-2')).toHaveCount(0);
+
+  // No invented live programme during the gap; exactly at 16:30 the
+  // synthetic marker vanishes and the next actual reference slot is active.
+  await page.clock.runFor(60_000);
+  await expect(marker).toHaveCount(0);
+  await expect(nextSlot.locator('.absolute.inset-y-2')).toHaveCount(1);
+});
+
+test('manual browsing in a missing-guide window does not get auto-recentered', async ({ page }) => {
+  await page.setViewportSize({ width: 1536, height: 900 });
+  await page.clock.install({ time: new Date('2026-10-14T04:30:00Z') }); // 11:30 ICT
+  await page.goto('/asia/viet-nam/vov-gt-hcm');
+  await page.waitForFunction(() => Boolean(document.querySelector('#__nuxt')?.__vue_app__));
+  await page.locator('.radio-player-dock').getByRole('button', { name: 'Channels & schedule' }).click();
+  await queue(page).getByRole('tab', { name: /Schedule/ }).click();
+
+  const scroll = scrollArea(page);
+  const marker = queue(page).locator('[data-schedule-now]');
+  await expect(marker).toContainText('11:30');
+  await expect(marker).toContainText('12:30');
+  await scroll.evaluate(node => { node.scrollTop = 0; });
+  await scroll.dispatchEvent('wheel', { deltaY: -200, bubbles: true });
+  await page.clock.runFor(16_000);
+  expect(await scroll.evaluate(node => node.scrollTop)).toBe(0);
+  await queue(page).getByRole('button', { name: 'Jump to current time' }).click();
+  await expect.poll(() => scroll.evaluate(node => node.scrollTop)).toBeGreaterThan(0);
+});
+
+test('1-second time bar moves during an unlisted gap and transfers into scheduled show', async ({ page }) => {
+  await page.setViewportSize({ width: 1536, height: 900 });
+  await page.clock.install({ time: new Date('2026-10-14T09:29:00Z') });
+  await page.goto('/asia/viet-nam/vov-gt-hcm');
+  await page.waitForFunction(() => Boolean(document.querySelector('#__nuxt')?.__vue_app__));
+  await page.locator('.radio-player-dock').getByRole('button', { name: 'Channels & schedule' }).click();
+  await queue(page).getByRole('tab', { name: /Schedule/ }).click();
+
+  const marker = queue(page).locator('[data-schedule-now]');
+  const time = marker.locator('[data-schedule-clock]');
+  const line = marker.locator('[data-schedule-time-progress]');
+  await expect(time).toHaveText('16:29:00');
+  const initialProgress = await line.evaluate(element => parseFloat(element.style.width));
+  expect(initialProgress).toBeCloseTo(93.333, 1);
+
+  await page.clock.runFor(2_000);
+  await expect(time).toHaveText('16:29:02');
+  const advancedProgress = await line.evaluate(element => parseFloat(element.style.width));
+  expect(advancedProgress).toBeGreaterThan(initialProgress);
+
+  await page.clock.runFor(58_000); // Exactly 16:30 ICT.
+  await expect(marker).toHaveCount(0);
+  const programme = queue(page).locator('[data-program-index="7"]');
+  await expect(programme.locator('[data-schedule-clock]')).toContainText('16:30:00');
+  const showProgress = programme.locator('[data-schedule-time-progress]');
+  await expect(showProgress).toHaveCount(1);
+  expect(await showProgress.evaluate(element => parseFloat(element.style.width))).toBe(0);
+  await page.clock.runFor(2_000);
+  expect(await showProgress.evaluate(element => parseFloat(element.style.width))).toBeGreaterThan(0);
 });
diff --git a/tests/station-schedule.test.mjs b/tests/station-schedule.test.mjs
index 46879c78..85fca521 100644
--- a/tests/station-schedule.test.mjs
+++ b/tests/station-schedule.test.mjs
@@ -5,6 +5,8 @@ import {
   isZingScheduleUrl,
   normalizeScheduleUrl,
   schedulePosition,
+  referenceScheduleGap,
+  scheduleTimelineProgress,
 } from "../utils/station-schedule.mjs";
 
 test("normalizes only real HTTP schedule URLs", () => {
@@ -67,3 +69,99 @@ test('legacy remote schedule keeps the provider first programme convention', ()
   const schedule = [{ title: 'Provider now' }, { title: 'Later' }];
   assert.deepEqual(schedulePosition(schedule, 1234, false), { currentIndex: 0, scrollIndex: 0 });
 });
+
+test('16:29 ICT is an unlisted gap before VOV Giao thông TP.HCM 16:30', async () => {
+  const { vietnamReferencePrograms } = await import('../utils/vietnam-schedules.mjs');
+  const programs = vietnamReferencePrograms('/asia/viet-nam/vov-gt-hcm', new Date('2026-10-14T09:29:00Z'));
+  const nowSeconds = Date.parse('2026-10-14T09:29:00Z') / 1000;
+  const gap = referenceScheduleGap(programs, nowSeconds);
+  assert.deepEqual(gap, {
+    insertIndex: 7,
+    nextTitle: 'Giờ cao điểm chiều',
+    nextStartTime: Date.parse('2026-10-14T09:30:00Z') / 1000,
+  });
+  assert.deepEqual(schedulePosition(programs, nowSeconds, true), { currentIndex: -1, scrollIndex: 7 });
+  assert.equal(referenceScheduleGap(programs, nowSeconds + 60), null,
+    '16:30 switches to the actual on-air slot, removing the gap marker');
+  assert.deepEqual(schedulePosition(programs, nowSeconds + 60, true), { currentIndex: 7, scrollIndex: 7 });
+});
+
+test('unlisted reference gaps include before first, between slots and after last', () => {
+  const schedule = [
+    { startTime: 100, endTime: 200, title: 'First' },
+    { startTime: 300, endTime: 400, title: 'Next' },
+  ];
+  assert.deepEqual(referenceScheduleGap(schedule, 50),
+    { insertIndex: 0, nextTitle: 'First', nextStartTime: 100 });
+  assert.equal(referenceScheduleGap(schedule, 150), null);
+  assert.deepEqual(referenceScheduleGap(schedule, 250),
+    { insertIndex: 1, nextTitle: 'Next', nextStartTime: 300 });
+  assert.equal(referenceScheduleGap(schedule, 300), null);
+  assert.deepEqual(referenceScheduleGap(schedule, 400),
+    { insertIndex: 2, nextTitle: '', nextStartTime: null });
+  assert.equal(referenceScheduleGap([], 250), null);
+  assert.equal(referenceScheduleGap(null, 250), null);
+  assert.equal(referenceScheduleGap(schedule, NaN), null);
+});
+
+test('Queue UI scrolls to missing-programme marker, never displays the next show as live', async () => {
+  const { readFile } = await import('node:fs/promises');
+  const queue = await readFile(new URL('../components/player/Queue.vue', import.meta.url), 'utf8');
+  const marker = await readFile(new URL('../components/player/ScheduleGap.vue', import.meta.url), 'utf8');
+  assert.match(queue, /scheduleGap\.value\s*\?\s*container\?\.querySelector<HTMLElement>\('\[data-schedule-now\]'\)/);
+  assert.match(queue, /scheduleGap\?\.insertIndex === index/);
+  assert.match(queue, /scheduleGap\?\.insertIndex === program\.length/);
+  assert.match(marker, /data-schedule-now/);
+  assert.match(marker, /panel\.schedule_gap_unknown/);
+  assert.match(marker, /panel\.schedule_gap_next/);
+  assert.doesNotMatch(marker, /player\.live|schedule_loading/);
+});
+
+test('live timeline percentage advances smoothly with wall-clock seconds', () => {
+  assert.equal(scheduleTimelineProgress(100, 200, 100), 0);
+  assert.equal(scheduleTimelineProgress(100, 200, 125), 25);
+  assert.equal(scheduleTimelineProgress(100, 200, 150), 50);
+  assert.equal(scheduleTimelineProgress(100, 200, 199), 99);
+  assert.equal(scheduleTimelineProgress(100, 200, 200), 100);
+  assert.equal(scheduleTimelineProgress(100, 200, 90), 0);
+  assert.equal(scheduleTimelineProgress(100, 200, 250), 100);
+  assert.equal(scheduleTimelineProgress(null, 200, 150), null);
+  assert.equal(scheduleTimelineProgress(100, null, 150), null);
+  assert.equal(scheduleTimelineProgress(200, 200, 150), null);
+  assert.equal(scheduleTimelineProgress(300, 200, 150), null);
+  assert.equal(scheduleTimelineProgress(100, 200, Number.NaN), null);
+});
+
+test('VOV HCM at 16:29 shows 93.33% of the 16:15–16:30 gap, ticking every second', async () => {
+  const { vietnamReferencePrograms } = await import('../utils/vietnam-schedules.mjs');
+  const now = Date.parse('2026-10-14T09:29:00Z') / 1000; // ICT +07:00.
+  const programs = vietnamReferencePrograms('/asia/viet-nam/vov-gt-hcm', new Date(now * 1000));
+  const gap = referenceScheduleGap(programs, now);
+  assert.equal(gap.insertIndex, 7);
+  const start = programs[gap.insertIndex - 1].endTime;
+  const end = gap.nextStartTime;
+  assert.equal(new Date(start * 1000).toISOString(), '2026-10-14T09:15:00.000Z');
+  assert.equal(scheduleTimelineProgress(start, end, now), 100 * 14 / 15);
+  assert.ok(scheduleTimelineProgress(start, end, now + 1) > scheduleTimelineProgress(start, end, now));
+  assert.equal(scheduleTimelineProgress(start, end, end), 100);
+  assert.equal(referenceScheduleGap(programs, end), null);
+  const show = programs[gap.insertIndex];
+  assert.equal(scheduleTimelineProgress(show.startTime, show.endTime, end), 0);
+  assert.ok(scheduleTimelineProgress(show.startTime, show.endTime, end + 1) > 0);
+});
+
+test('live time bar is wired to a one-second clock only for visible reference guides', async () => {
+  const { readFile } = await import('node:fs/promises');
+  const q = await readFile(new URL('../components/player/Queue.vue', import.meta.url), 'utf8');
+  const gap = await readFile(new URL('../components/player/ScheduleGap.vue', import.meta.url), 'utf8');
+  assert.match(q, /scheduleTimelineProgress\(item\.startTime, item\.endTime, scheduleNow\.value\)/);
+  assert.match(q, /scheduleClockTimer = setInterval\(/);
+  assert.match(q, /\}, 1_000\)/);
+  assert.match(q, /props\.visible && props\.scheduleIsReference/);
+  assert.match(q, /data-schedule-clock role="timer"/);
+  assert.match(q, /data-schedule-time-progress/);
+  assert.match(q, /:start-time="gapStartTime\(scheduleGap\.insertIndex\)"/);
+  assert.match(gap, /second: '2-digit'/);
+  assert.match(gap, /data-schedule-time-progress/);
+  assert.match(gap, /timelineProgress \+ '%'/);
+});
diff --git a/utils/station-schedule.mjs b/utils/station-schedule.mjs
index c6283410..99c5ef54 100644
--- a/utils/station-schedule.mjs
+++ b/utils/station-schedule.mjs
@@ -47,3 +47,42 @@ export const schedulePosition = (programs, nowSeconds, isReference = false) => {
     scrollIndex: upcomingIndex !== -1 ? upcomingIndex : programs.length - 1,
   };
 };
+
+// A missing block of *reference metadata* is not evidence that the radio has
+// stopped broadcasting. Show a neutral "programme not listed" time marker,
+// rather than attributing the next programme to the current moment.
+// Index is where the marker belongs among chronologically ordered programmes.
+export const referenceScheduleGap = (programs, nowSeconds) => {
+  if (!Array.isArray(programs) || !programs.length || !Number.isFinite(nowSeconds)) return null;
+  for (let index = 0; index < programs.length; index++) {
+    const next = programs[index];
+    if (!Number.isFinite(next?.startTime) || !Number.isFinite(next?.endTime)) return null;
+    if (next.startTime <= nowSeconds && nowSeconds < next.endTime) return null;
+    if (nowSeconds < next.startTime) {
+      const previous = programs[index - 1];
+      // Explicit inter-programme gaps and time before the first listed slot.
+      if (!previous || (Number.isFinite(previous.endTime) && nowSeconds >= previous.endTime)) {
+        return {
+          insertIndex: index,
+          nextTitle: next.title || '',
+          nextStartTime: next.startTime,
+        };
+      }
+      return null;
+    }
+  }
+  // Today's published guide has finished. Don't label this as off-air.
+  const last = programs[programs.length - 1];
+  return Number.isFinite(last?.endTime) && nowSeconds >= last.endTime
+    ? { insertIndex: programs.length, nextTitle: '', nextStartTime: null }
+    : null;
+};
+
+// Percentage of actual elapsed wall-clock time in a scheduled interval.
+// Used only as a reference-guide timeline, not an audio playback progress bar.
+// Invalid or unknown bounds intentionally have no calculable position.
+export const scheduleTimelineProgress = (startSeconds, endSeconds, nowSeconds) => {
+  if (!Number.isFinite(startSeconds) || !Number.isFinite(endSeconds)
+      || !Number.isFinite(nowSeconds) || endSeconds <= startSeconds) return null;
+  return Math.min(100, Math.max(0, (nowSeconds - startSeconds) * 100 / (endSeconds - startSeconds)));
+};