cronli5 0.8.0 → 0.8.2

package/src/lang/en/index.ts

@@ -581,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);
   }
 
@@ -703,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.
@@ -932,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) +
@@ -1748,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

@@ -467,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.
@@ -594,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);
@@ -680,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);
@@ -1271,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

@@ -426,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
@@ -473,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
@@ -695,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
@@ -714,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);
   }
 
@@ -1167,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

@@ -476,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.
@@ -550,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);
@@ -635,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);
@@ -991,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

@@ -616,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.
@@ -746,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);
@@ -832,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);
@@ -1423,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);

package/src/lang/zh/index.ts

@@ -327,6 +327,16 @@ function renderMinutePast(schedule: Schedule): string {
   return minuteHourClause(schedule);
 }
 
+// Strip the generic "每小时" (every-hour) anchor that leads a minute clause.
+// Under an hour STEP the hour cadence is the sole hour authority, so the minute
+// clause must not also assert "每小时" — alongside a stepped hour ("每4小时…每小
+// 时…") it reads as a conflicting every-hour scope. An hour WINDOW and an
+// unrestricted hour keep "每小时" (the window already names the hours; an open
+// hour has no other hour statement).
+function withoutHourAnchor(clause: string): string {
+  return clause.replace(/^每小时/, '');
+}
+
 // One hour segment as clock words by its form: a range is a span ("9点至20点"),
 // a single is one clock word ("22点"), a step keeps its fires enumerated as
 // clock words ("9点、11点、13点"). A range stated as a list element should read
@@ -383,7 +393,14 @@ function renderMinuteFrequency(schedule: Schedule, plan: PlanNode): string {
     const hourCad = unevenHourCadence(schedule);
 
     if (hourCad !== null) {
-      return hourCad + (hourCad.indexOf('至') === -1 ? '' : '，') + base;
+      // An hour STEP is the sole hour authority, so an offset minute cadence
+      // drops its leading "每小时" ("每4小时从5分起每10分钟"); a discrete hour
+      // list (during) keeps it. Only the step path reaches a non-null cadence
+      // here — an irregular list falls through to the enumerated frame below.
+      const minuteBase = hours.kind === 'step' ?
+        withoutHourAnchor(base) : base;
+
+      return hourCad + (hourCad.indexOf('至') === -1 ? '' : '，') + minuteBase;
     }
   }
 
@@ -445,15 +462,17 @@ function renderMinuteSpanAcrossHourStep(
   const {form} = plan as Extract<PlanNode, {kind: 'minuteSpanAcrossHourStep'}>;
 
   // A minute list reads as the hour cadence plus the minute list ("每2小时，
-  // 每小时0、25、50分"; offset "从1点起每2小时，每小时5分和30分"), the same compaction
-  // the wildcard/range minute already uses, rather than the enumerated hours.
+  // 0、25、50分"; offset "从1点起每2小时，5分和30分"), the same compaction the
+  // wildcard/range minute already uses, rather than the enumerated hours. The
+  // hour cadence scopes the hours, so the minute clause drops its "每小时".
   if (form === 'list') {
-    return hourCadencePhrase(schedule) + '，' + renderMinutePast(schedule);
+    return hourCadencePhrase(schedule) + '，' +
+      withoutHourAnchor(renderMinutePast(schedule));
   }
 
   const minuteTail = form === 'wildcard' ?
     '每分钟' :
-    minuteHourClause(schedule) + '，每分钟';
+    withoutHourAnchor(minuteHourClause(schedule)) + '，每分钟';
 
   // An offset or non-tiling stride (2/6 fires at 2,8,14,20) reads as its
   // cadence ("从2点起每6小时"). A wildcard minute hangs off it with a comma; a
@@ -518,9 +537,13 @@ function renderCompactClockTimes(schedule: Schedule, plan: PlanNode): string {
   if (!compact.fold) {
     const hourCad = unevenHourCadence(schedule);
 
+    // A bounded/uneven hour step leads as the cadence and is the sole hour
+    // authority, so the minute clause drops its generic "每小时" every-hour
+    // scope; an enumerated hour list (hourCad null) names specific hours and
+    // keeps the anchor.
     return hourCad === null ?
       minuteHourClause(schedule) + '，在' + hourList(schedule) + tail :
-      hourCad + '，' + minuteHourClause(schedule) + tail;
+      hourCad + '，' + withoutHourAnchor(minuteHourClause(schedule)) + tail;
   }
 
   // A single pinned minute past 0 leads with its clause; a pinned 0 folds into
@@ -870,6 +893,15 @@ function composeSecondsOnHour(
     return composeMinuteZeroClocks(schedule, sec);
   }
 
+  // A single fixed (non-zero) minute under enumerated clock times fuses the
+  // seconds onto the composed clock time the same way ("0点2分的每一秒").
+  const fusedSingleMinute =
+    composeSingleMinuteClocks(schedule, rest, sec, opts);
+
+  if (fusedSingleMinute !== null) {
+    return fusedSingleMinute;
+  }
+
   const restText = render(schedule, rest, opts);
   const secTail = clockRestCarriesSecond(rest) ? '' : sec;
 
@@ -886,6 +918,29 @@ function composeSecondsOnHour(
   return restText + secTail;
 }
 
+// A single fixed (non-zero) minute under enumerated clock times: each clock
+// point already names the minute ("0点2分", "9点5分和17点5分"), so bind the
+// seconds to it with "的" — the same fusion the minute-0 ("0分的每一秒") and
+// minute-step ("5、20…分的每一秒") cases use — rather than leaving a bare
+// trailing "每秒" that floats as a second, unlinked adverbial. A single second
+// already folded into each clock time ("9点5分30秒") is not re-appended. The
+// compactClockTimes window form states its minute separately ("每小时5分") and
+// keeps its own seconds clause, so it does not qualify (returns null). minute 0
+// is handled by composeMinuteZeroClocks before this point.
+function composeSingleMinuteClocks(
+  schedule: Schedule, rest: PlanNode, sec: string, opts: Opts
+): string | null {
+  if (rest.kind !== 'clockTimes' || schedule.shapes.minute !== 'single' ||
+      clockRestCarriesSecond(rest)) {
+    return null;
+  }
+
+  const core =
+    render(schedule, rest, opts) + minuteZeroSecondTail(schedule, sec);
+
+  return isDaily(schedule) ? '每天' + core : core;
+}
+
 // A minute pinned to 0 under specific clock hours (not a compacted cadence): a
 // bare clock word ("9点") would hide the :00 and leave the second dangling
 // ("…9点每秒"), reading as the whole hour. Fuse the seconds with the explicit
@@ -907,14 +962,24 @@ function composeMinuteZeroClocks(schedule: Schedule, sec: string): string {
     // midnight (凌晨0点) and other hours still need it to pin the minute.
     return hour === 12 ? '正午' : hourWord(hour) + '0分';
   });
-  // A pinned minute makes the seconds' own "每分钟" anchor misleading (it is a
-  // single minute, not every minute), so the stride here drops it.
+  const core = joinAnd(clocks) + minuteZeroSecondTail(schedule, sec);
+
+  return isDaily(schedule) ? '每天' + core : core;
+}
+
+// The "的"-fused second tail for a clock time that already names a single pinned
+// minute ("…的每一秒" for a wildcard second, else "…的" + the second's clause).
+// A pinned minute makes the seconds' own "每分钟" anchor misleading (it is a
+// single minute, not every minute), so a stride here drops it.
+function minuteZeroSecondTail(schedule: Schedule, sec: string): string {
+  if (sec === '每秒') {
+    return '的每一秒';
+  }
+
   const nested =
     strideFromSegments(segmentsOf(schedule, 'second'), '秒', '秒', '');
-  const tail = sec === '每秒' ? '的每一秒' : '的' + (nested ?? sec);
-  const core = joinAnd(clocks) + tail;
 
-  return isDaily(schedule) ? '每天' + core : core;
+  return '的' + (nested ?? sec);
 }
 
 // Whether the hour field is a range — or a list whose segments include a
@@ -1010,7 +1075,10 @@ function composeSecondsListed(schedule: Schedule): string {
   const hourCad = unevenHourCadence(schedule);
 
   if (hourCad !== null) {
-    return hourCad + '，' + minutes + '，' + sec;
+    // An hour STEP cadence is the sole hour authority, so the minute clause
+    // drops its "每小时" ("每2小时，0至30分，每秒"); a discrete hour list keeps it
+    // (it falls through to the hourFrame branch below with a null cadence).
+    return hourCad + '，' + withoutHourAnchor(minutes) + '，' + sec;
   }
 
   return hourFrame(schedule) + minutes + '，' + sec;