cronli5 0.7.2 → 0.8.2

package/src/lang/de/index.ts

@@ -738,12 +738,13 @@ function renderComposeSeconds(
     }
   }
 
-  // A sub-minute second with the minute pinned to 0 and a specific hour: the
-  // clock-time rest would read "um 9 Uhr", which hides the pinned :00 (and so
-  // the one-minute confinement — 60 fires in :00, not 3,600 across the hour).
-  // Bind the seconds into the explicit clock minute in the genitive ("der
-  // Minute 9:00"); the recurring "täglich"/day frame is added in `describe`.
-  if (composeMinuteZero(schedule, plan)) {
+  // A second over a single fixed minute and a specific hour is a single fixed
+  // timestamp: the clock-time rest would float the seconds as a separate
+  // apposition ("jede Sekunde, um 9:02 Uhr"), hiding that they belong to that
+  // one minute. Bind the seconds into the explicit clock minute in the genitive
+  // ("der Minute 9:02"), the same fusion the minute-0 case ("der Minute 9:00")
+  // uses; the recurring "täglich"/day frame is added in `describe`.
+  if (composeSingleMinute(schedule, plan)) {
     return secondsLead(schedule) + ' ' +
       clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
@@ -765,21 +766,23 @@ function renderComposeSeconds(
   return lead + render(schedule, plan.rest, opts);
 }
 
-// True when a compose-seconds plan is a sub-minute second over a minute-0
-// clock-time rest — the case that reads as the bare hour and so must surface
-// the pinned clock minute.
-function composeMinuteZero(
+// True when a compose-seconds plan is a sub-minute second over a single fixed
+// minute's clock-time rest — the single fixed timestamp whose seconds must fuse
+// to the explicit clock minute rather than float as a separate apposition.
+// Minute 0 ("der Minute 0:00") is just this with the minute being 0; any single
+// fixed minute fuses the same way.
+function composeSingleMinute(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>
 ): plan is Extract<PlanNode, {kind: 'composeSeconds'}> &
   {rest: Extract<PlanNode, {kind: 'clockTimes'}>} {
   return plan.rest.kind === 'clockTimes' &&
-    plan.rest.times.every((time) => +time.minute === 0);
+    schedule.shapes.minute === 'single';
 }
 
-// The pinned clock minute in the genitive: "der Minute 9:00" for one hour,
-// "der Minuten 9:00, 10:00 und 17:00" for several — the explicit ":00" so the
-// minute-0 confinement stays visible.
+// The pinned clock minute in the genitive: "der Minute 9:02" for one hour,
+// "der Minuten 9:00, 10:00 und 17:00" for several — the explicit minute so the
+// single-fixed-minute confinement stays visible.
 function clockMinuteGenitive(
   times: {hour: number; minute: number}[],
   sep: string
@@ -940,18 +943,22 @@ function renderMinuteFrequency(
   if (plan.hours.kind === 'during') {
     // A bounded or uneven hour stride confines the minute cadence to its own
     // endpoint-pinning hour cadence ("alle 15 Minuten, alle 5 Stunden von 0 bis
-    // 20 Uhr").
+    // 20 Uhr"). That hour step is the sole hour authority, so an offset minute
+    // cadence drops its generic "jeder Stunde" (an every-hour scope conflicting
+    // with the step); a list of specific hours keeps it.
     const cadence = unevenHourCadence(schedule);
 
     return cadence ?
-      base + ', ' + cadence :
+      stepClause(segment, UNITS.minute, '') + ', ' + cadence :
       base + ' ' + duringHours(schedule, plan.hours.times, sep);
   }
 
   if (plan.hours.kind === 'step') {
     // The plan carries a step only for a clean step (dividing the day):
-    // confine the cadence to every Nth hour ("in jeder zweiten Stunde").
-    return base + ' ' +
+    // confine the cadence to every Nth hour ("in jeder zweiten Stunde"). The
+    // hour step is the sole hour authority, so the minute cadence drops its
+    // generic "jeder Stunde".
+    return stepClause(segment, UNITS.minute, '') + ' ' +
       everyNthHour(stepSegment(schedule, 'hour'));
   }
 
@@ -1405,28 +1412,31 @@ function qualifier(schedule: Schedule, months: Months): string {
 
 // Plan kinds whose clause is a clock time: the qualifier leads them ("montags
 // um 9 Uhr"); a frequency clause trails it ("jede Minute montags"). The
-// minute-0 compose-seconds clause is anchored on a clock minute too, so the
-// qualifier leads it ("montags jede Sekunde der Minute 9:00").
+// single-fixed-minute compose-seconds clause is anchored on a clock minute too,
+// so the qualifier leads it ("montags jede Sekunde der Minute 9:00").
 const LEADING_PLANS = new Set(['clockTimes']);
 
 // True when the leading qualifier should precede the clause: a clock-time
-// plan, or the minute-0 compose-seconds clause that surfaces a clock minute.
+// plan, or the single-fixed-minute compose-seconds clause that surfaces a clock
+// minute.
 function leadsQualifier(schedule: Schedule): boolean {
-  return LEADING_PLANS.has(schedule.plan.kind) || isComposeMinuteZero(schedule);
+  return LEADING_PLANS.has(schedule.plan.kind) ||
+    isComposeSingleMinute(schedule);
 }
 
-// Whether the planned clause is the minute-0 compose-seconds confinement
-// (a sub-minute second over a minute-0 clock-time rest).
-function isComposeMinuteZero(schedule: Schedule): boolean {
+// Whether the planned clause is the single-fixed-minute compose-seconds
+// confinement (a sub-minute second over a single fixed minute's clock-time
+// rest).
+function isComposeSingleMinute(schedule: Schedule): boolean {
   return schedule.plan.kind === 'composeSeconds' &&
-    composeMinuteZero(schedule, schedule.plan);
+    composeSingleMinute(schedule, schedule.plan);
 }
 
 // True when the clause is a bare daily clock-time list and so needs the
 // "täglich" frame to read as recurring, not a one-off: clockTimes always, the
-// minute-0 compose-seconds clause (a recurring clock minute), and an uneven
-// hour step (rendered as its fire list "um 0, 5, … Uhr", not the cadence "alle
-// N Stunden"). A frequency clause already implies recurrence.
+// single-fixed-minute compose-seconds clause (a recurring clock minute), and an
+// uneven hour step (rendered as its fire list "um 0, 5, … Uhr", not the cadence
+// "alle N Stunden"). A frequency clause already implies recurrence.
 function needsDailyFrame(schedule: Schedule): boolean {
   // An hour cadence is a sub-daily frequency, not a daily clock-time list, so
   // it must not take the "täglich" frame ("alle 2 Stunden", not "täglich alle
@@ -1435,7 +1445,7 @@ function needsDailyFrame(schedule: Schedule): boolean {
     return false;
   }
 
-  if (schedule.plan.kind === 'clockTimes' || isComposeMinuteZero(schedule)) {
+  if (schedule.plan.kind === 'clockTimes' || isComposeSingleMinute(schedule)) {
     return true;
   }
 
@@ -1464,6 +1474,7 @@ function normalizeOptions(options?: Cronli5Options): Opts {
   return {
     ampm: typeof options.ampm === 'boolean' ? options.ampm : false,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style,

package/src/lang/en/index.ts

@@ -137,6 +137,7 @@ function normalizeOptions(options?: Cronli5Options): NormalizedOptions {
   return {
     ampm: typeof options.ampm === 'boolean' ? options.ampm : true,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style: resolveDialect(options.dialect),
@@ -580,8 +581,11 @@ function renderMinuteFrequency(schedule: Schedule,
   else if (plan.hours.kind === 'step') {
     // The plan carries a step only for a clean stride (dividing the day),
     // which confines the cadence to every Nth hour; a stepped hour field's
-    // first segment is a step segment.
-    phrase += ' ' +
+    // first segment is a step segment. The hour step scopes the hours, so an
+    // offset cadence drops "past the hour" and joins with a comma.
+    const bound = withoutHourAnchor(phrase);
+
+    phrase = bound + (bound === phrase ? ' ' : ', ') +
       everyNthHour(stepSegment(schedule, 'hour'), opts);
   }
 
@@ -702,13 +706,14 @@ function renderMinuteSpanAcrossHourStep(schedule: Schedule,
   }
 
   // A minute list keeps the same cadence clause; only its lead differs. An
-  // offset/uneven step the core enumerated to that list reads as a stride.
-  const lead = plan.form === 'list' ?
+  // offset/uneven step the core enumerated to that list reads as a stride. The
+  // hour step scopes the hours, so the lead drops its generic "past the hour".
+  const lead = withoutHourAnchor(plan.form === 'list' ?
     strideFromSegments(segmentsOf(schedule, 'minute'), 'minute', 'hour',
       opts) ??
       listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
         'minute', 'hour', opts) :
-    minuteRangeLead(schedule.pattern.minute, opts);
+    minuteRangeLead(schedule.pattern.minute, opts));
   // A bounded or uneven hour step reads as its endpoint-pinning cadence after
   // the minute lead, not a wall of clock-time columns; an offset-clean step
   // keeps its existing per-step phrasing.
@@ -931,10 +936,14 @@ function renderCompactClockTimes(schedule: Schedule,
       listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
         'minute', 'hour', opts);
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
-  // of clock-time columns.
+  // of clock-time columns. The hour step is the sole hour authority there, so
+  // the minute lead drops its generic "past the hour" (an every-hour scope that
+  // would conflict with the step); the clock-time branch keeps it, naming
+  // specific hours rather than a step.
   const cadence = unevenHourCadence(schedule, opts);
   const phrase = cadence ?
-    minuteLead + ', ' + cadence + trailingQualifier(schedule, opts) :
+    withoutHourAnchor(minuteLead) + ', ' + cadence +
+      trailingQualifier(schedule, opts) :
     minuteLead +
     ', at ' +
     hourSegmentTimes(schedule, {minute: 0, second: null}, true, opts) +
@@ -1747,6 +1756,15 @@ function listPastThe(words: (string | number)[], unit: string, anchor: string,
     anchor;
 }
 
+// Strip the generic "past the hour" anchor from a minute-cadence lead. When the
+// hour field is restricted (a step or window), the hour clause is the sole hour
+// authority, so the cadence must not also assert "every hour" — "past the hour"
+// alongside a stepped/windowed hour reads as a conflicting every-hour scope. An
+// unrestricted hour keeps the anchor (it is the only hour statement there).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(/ past the hour$/, '');
+}
+
 // A clock time reads as a word ("noon"/"midnight") only at exact 12:00 or
 // 0:00 with no minute or second.
 function wordTime(hour: number | string, minute: number | string,

package/src/lang/es/index.ts

@@ -125,6 +125,7 @@ function normalizeOptions(options?: Cronli5Options): Opts {
     // 12-hour for Mexico/US); an explicit `{ampm}` option overrides it.
     ampm: typeof options.ampm === 'boolean' ? options.ampm : style.ampm,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style,
@@ -466,6 +467,16 @@ function minutesList(schedule: Schedule, opts: Opts): string {
     joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de cada hora';
 }
 
+// Strip the generic "de cada hora" anchor from a minute-cadence lead. Under an
+// hour STEP the hour clause is the sole hour authority, so the cadence must not
+// also assert "de cada hora" — alongside a stepped hour it reads as a
+// conflicting every-hour scope ("de cada hora, cada cuatro horas"). An hour
+// WINDOW and an unrestricted hour keep the anchor (the window already names the
+// hours; an open hour has no other hour statement).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(/ de cada hora$/, '');
+}
+
 // "cada minuto del 0 al 30". The standalone renderer adds "de cada hora";
 // when an hour qualifier follows ("..., a las 09:00", "..., cada dos
 // horas") it would contradict, so it is not baked in here.
@@ -593,8 +604,10 @@ function renderMinuteFrequency(
   }
   else if (plan.hours.kind === 'step') {
     // A clean stride is a confinement ("las horas pares", or the active-hour
-    // list), never a juxtaposed cadence ("cada dos horas").
-    phrase += ', ' + stepHourSpan(stepSegment(schedule, 'hour'), opts);
+    // list), never a juxtaposed cadence ("cada dos horas"). The hour step
+    // scopes the hours, so an offset cadence drops "de cada hora".
+    phrase = withoutHourAnchor(phrase) + ', ' +
+      stepHourSpan(stepSegment(schedule, 'hour'), opts);
   }
 
   return phrase + trailingQualifier(schedule, opts);
@@ -679,10 +692,10 @@ function renderMinuteSpanAcrossHourStep(
 
   // A minute list keeps the same cadence clause as the range; only its lead
   // differs ("en los minutos 5 y 30 de cada hora" vs "cada minuto del 0 al
-  // 30").
-  const lead = plan.form === 'list' ?
+  // 30"). The hour step scopes the hours, so the lead drops "de cada hora".
+  const lead = withoutHourAnchor(plan.form === 'list' ?
     minutesList(schedule, opts) :
-    minuteRangeLead(schedule.pattern.minute);
+    minuteRangeLead(schedule.pattern.minute));
 
   return lead + ', ' +
     (cadence ?? stepHours(segment, opts)) + trailingQualifier(schedule, opts);
@@ -1270,10 +1283,13 @@ function renderCompactClockTimes(
   }
 
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
-  // of clock-time columns.
+  // of clock-time columns. That hour step is the sole hour authority, so the
+  // minute lead drops its generic "de cada hora" (an every-hour scope that
+  // would conflict with the step); the clock-time branch keeps it, naming
+  // specific hours rather than a step.
   const cadence = unevenHourCadence(schedule, opts);
   const phrase = cadence ?
-    minutesList(schedule, opts) + ', ' + cadence +
+    withoutHourAnchor(minutesList(schedule, opts)) + ', ' + cadence +
       trailingQualifier(schedule, opts) :
     minutesList(schedule, opts) + ', ' +
       hourContextTimes(schedule, opts) + trailingQualifier(schedule, opts);

package/src/lang/fi/index.ts

@@ -200,6 +200,7 @@ function normalizeOptions(options?: Cronli5Options): NormalizedOptions {
   return {
     ampm: false,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style: resolveDialect(options.dialect),
@@ -425,15 +426,15 @@ function renderComposeSeconds(
     return composeSecondsOverMinuteStep(schedule, plan.rest, opts);
   }
 
-  // A sub-minute second with the minute pinned to 0 and a specific hour: the
-  // clock-time rest would read "klo 9", dropping the pinned :00 and so the
-  // one-minute confinement (60 fires in :00, not 3,600 across the hour). Bind
-  // the seconds to the explicit clock minute with the "minuutin HH.00 aikana"
-  // frame (an "of"/during form, never a range) and trail the day qualifier
-  // ("joka sekunti minuutin 9.00 aikana, joka päivä").
-  if (plan.rest.kind === 'clockTimes' &&
-      plan.rest.times.every((time) => +time.minute === 0)) {
-    return composeMinuteZero(schedule, plan.rest, opts);
+  // A second over a single fixed minute and a specific hour is a single fixed
+  // timestamp: the clock-time rest would float the seconds as a separate clause
+  // ("joka sekunti, joka päivä klo 9.02"), hiding that they belong to that one
+  // minute. Bind the seconds to the explicit clock minute with the "minuutin
+  // HH.MM aikana" frame (an "of"/during form, never a range) and trail the day
+  // qualifier ("joka sekunti minuutin 9.02 aikana, joka päivä") — the same
+  // fusion the minute-0 case ("minuutin 9.00 aikana") uses.
+  if (plan.rest.kind === 'clockTimes' && schedule.shapes.minute === 'single') {
+    return composeSingleMinute(schedule, plan.rest, opts);
   }
 
   // A wildcard second under a minute */2 with a wildcard hour juxtaposes two
@@ -472,11 +473,13 @@ function isEveryOtherMinuteSeconds(
   return seg.startToken === '*' && seg.interval === 2;
 }
 
-// The minute-0 confinement: bind the seconds to the explicit clock minute(s)
-// in the "minuutin/minuuttien HH.00 aikana" frame (an "of"/during form, never
-// a range — a range would round-trip back to the whole hour) and trail the day
-// qualifier ("joka sekunti minuutin 9.00 aikana, joka päivä").
-function composeMinuteZero(
+// The single-fixed-minute confinement: bind the seconds to the explicit clock
+// minute(s) in the "minuutin/minuuttien HH.MM aikana" frame (an "of"/during
+// form, never a range — a range would round-trip back to the whole hour) and
+// trail the day qualifier ("joka sekunti minuutin 9.02 aikana, joka päivä").
+// Minute 0 ("minuutin 9.00 aikana") is just this with the minute being 0; any
+// single fixed minute fuses the same way.
+function composeSingleMinute(
   schedule: Schedule,
   rest: Extract<PlanNode, {kind: 'clockTimes'}>,
   opts: NormalizedOptions
@@ -694,8 +697,10 @@ function renderMinuteFrequency(
     const cadence = unevenHourCadence(schedule, opts);
 
     if (cadence !== null) {
-      return stepCycle60(seg, units.minute, opts) + ', ' + cadence +
-        trailingQualifier(schedule, opts);
+      // The hour step is the sole hour authority, so an offset minute cadence
+      // drops its generic "jokaisen tunnin" every-hour scope.
+      return withoutHourAnchor(stepCycle60(seg, units.minute, opts)) + ', ' +
+        cadence + trailingQualifier(schedule, opts);
     }
 
     // When the step renders as anchored ("kohdalla"), the per-hour windows
@@ -713,13 +718,16 @@ function renderMinuteFrequency(
       trailingQualifier(schedule, opts);
   }
 
-  let phrase = stepCycle60(seg, units.minute, opts);
+  const phraseBase = stepCycle60(seg, units.minute, opts);
+  let phrase = phraseBase;
 
   if (plan.hours.kind === 'window') {
     phrase += ' ' + hourWindow(plan.hours, opts);
   }
   else if (plan.hours.kind === 'step') {
-    phrase += ' ' +
+    // The hour step is the sole hour authority, so the minute cadence drops its
+    // generic "jokaisen tunnin" every-hour scope.
+    phrase = withoutHourAnchor(phraseBase) + ' ' +
       everyNthHour(stepSegment(schedule, 'hour'), opts);
   }
 
@@ -1166,6 +1174,16 @@ function stepCycle60(
   }, opts);
 }
 
+// Strip the generic "jokaisen tunnin" anchor from an offset minute-cadence
+// lead. When the hour field is a restricted step, the hour clause is the sole
+// hour authority, so the cadence must not also assert "jokaisen tunnin" (every
+// hour) — alongside a stepped hour it conflicts as an every-hour scope.
+// An unrestricted hour, and an hour WINDOW, keep the anchor (the window names
+// the hours without an every-hour-of-the-day conflict).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(' ' + units.minute.anchor + ' ', ' ');
+}
+
 // "kahden tunnin välein", "klo 0, 10 ja 20", or "viiden tunnin välein
 // klo 1 alkaen".
 function stepHours(segment: StepSegment, opts: NormalizedOptions): string {

package/src/lang/fr/index.ts

@@ -138,6 +138,7 @@ function normalizeOptions(options?: Cronli5Options): Opts {
     // satisfied without the 12-hour machinery the es donor carried.
     ampm: false,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style,
@@ -475,6 +476,16 @@ function minutesList(schedule: Schedule, opts: Opts): string {
     joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de chaque heure';
 }
 
+// Strip the generic "de chaque heure" anchor from a minute-cadence lead. Under
+// an hour STEP the hour clause is the sole hour authority, so the cadence must
+// not also assert "de chaque heure" — alongside a stepped hour it reads as a
+// conflicting every-hour scope ("de chaque heure, toutes les quatre heures").
+// An hour WINDOW and an unrestricted hour keep the anchor (the window already
+// names the hours; an open hour has no other hour statement).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(/ de chaque heure$/, '');
+}
+
 // "chaque minute de 0 à 30". The standalone renderer adds "de chaque heure";
 // when an hour qualifier follows ("..., à 9 h", "..., toutes les deux heures")
 // it would contradict, so it is not baked in here.
@@ -549,8 +560,10 @@ function renderMinuteFrequency(
   }
   else if (plan.hours.kind === 'step') {
     // A clean stride is a confinement ("les heures paires", or the active-hour
-    // list), never a juxtaposed cadence ("toutes les deux heures").
-    phrase += ', ' + stepHourSpan(stepSegment(schedule, 'hour'), opts);
+    // list), never a juxtaposed cadence ("toutes les deux heures"). The hour
+    // step scopes the hours, so an offset cadence drops "de chaque heure".
+    phrase = withoutHourAnchor(phrase) + ', ' +
+      stepHourSpan(stepSegment(schedule, 'hour'), opts);
   }
 
   return phrase + trailingQualifier(schedule, opts);
@@ -634,10 +647,10 @@ function renderMinuteSpanAcrossHourStep(
 
   // A minute list keeps the same cadence clause as the range; only its lead
   // differs ("aux minutes 5 et 30 de chaque heure" vs "chaque minute de 0 à
-  // 30").
-  const lead = plan.form === 'list' ?
+  // 30"). The hour step scopes the hours, so the lead drops "de chaque heure".
+  const lead = withoutHourAnchor(plan.form === 'list' ?
     minutesList(schedule, opts) :
-    minuteRangeLead(schedule.pattern.minute);
+    minuteRangeLead(schedule.pattern.minute));
 
   return lead + ', ' +
     (cadence ?? stepHours(segment, opts)) + trailingQualifier(schedule, opts);
@@ -990,10 +1003,13 @@ function renderCompactClockTimes(
   }
 
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
-  // of clock-time columns.
+  // of clock-time columns. That hour step is the sole hour authority, so the
+  // minute lead drops its generic "de chaque heure" (an every-hour scope that
+  // would conflict with the step); the clock-time branch keeps it, naming
+  // specific hours rather than a step.
   const cadence = unevenHourCadence(schedule, opts);
   const phrase = cadence ?
-    minutesList(schedule, opts) + ', ' + cadence +
+    withoutHourAnchor(minutesList(schedule, opts)) + ', ' + cadence +
       trailingQualifier(schedule, opts) :
     minutesList(schedule, opts) + ', ' +
       hourContextTimes(schedule, opts) + trailingQualifier(schedule, opts);

package/src/lang/pt/index.ts

@@ -269,6 +269,7 @@ function normalizeOptions(options?: Cronli5Options): Opts {
     // `{ampm}` option overrides it.
     ampm: typeof options.ampm === 'boolean' ? options.ampm : style.ampm,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style,
@@ -615,6 +616,16 @@ function minutesList(schedule: Schedule, opts: Opts): string {
     joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de cada hora';
 }
 
+// Strip the generic "de cada hora" anchor from a minute-cadence lead. Under an
+// hour STEP the hour clause is the sole hour authority, so the cadence must not
+// also assert "de cada hora" — alongside a stepped hour it reads as a
+// conflicting every-hour scope ("de cada hora, a cada quatro horas"). An hour
+// WINDOW and an unrestricted hour keep the anchor (the window already names the
+// hours; an open hour has no other hour statement).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(/ de cada hora$/, '');
+}
+
 // "a cada minuto do 0 ao 30". The standalone renderer adds "de cada hora";
 // when an hour qualifier follows ("..., às 09:00", "..., a cada duas horas")
 // it would contradict, so it is not baked in here.
@@ -745,8 +756,10 @@ function renderMinuteFrequency(
   }
   else if (plan.hours.kind === 'step') {
     // A clean stride is a confinement ("as horas pares", or the active-hour
-    // list), never a juxtaposed cadence ("a cada duas horas").
-    phrase += ', ' + stepHourSpan(stepSegment(schedule, 'hour'), opts);
+    // list), never a juxtaposed cadence ("a cada duas horas"). The hour step
+    // scopes the hours, so an offset cadence drops "de cada hora".
+    phrase = withoutHourAnchor(phrase) + ', ' +
+      stepHourSpan(stepSegment(schedule, 'hour'), opts);
   }
 
   return phrase + trailingQualifier(schedule, opts);
@@ -831,9 +844,10 @@ function renderMinuteSpanAcrossHourStep(
 
   // A minute list keeps the same cadence clause as the range; only its lead
   // differs ("nos minutos 5 e 30 de cada hora" vs "a cada minuto do 0 ao 30").
-  const lead = plan.form === 'list' ?
+  // The hour step scopes the hours, so the lead drops "de cada hora".
+  const lead = withoutHourAnchor(plan.form === 'list' ?
     minutesList(schedule, opts) :
-    minuteRangeLead(schedule.pattern.minute);
+    minuteRangeLead(schedule.pattern.minute));
 
   return lead + ', ' +
     (cadence ?? stepHours(segment, opts)) + trailingQualifier(schedule, opts);
@@ -1422,10 +1436,13 @@ function renderCompactClockTimes(
   }
 
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
-  // of clock-time columns.
+  // of clock-time columns. That hour step is the sole hour authority, so the
+  // minute lead drops its generic "de cada hora" (an every-hour scope that
+  // would conflict with the step); the clock-time branch keeps it, naming
+  // specific hours rather than a step.
   const cadence = unevenHourCadence(schedule, opts);
   const phrase = cadence ?
-    minutesList(schedule, opts) + ', ' + cadence +
+    withoutHourAnchor(minutesList(schedule, opts)) + ', ' + cadence +
       trailingQualifier(schedule, opts) :
     minutesList(schedule, opts) + ', ' +
       hourContextTimes(schedule, opts) + trailingQualifier(schedule, opts);