@nightlab-agent/date-check 0.1.0 → 0.1.2

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
       "name": "date-check",
       "source": "./",
       "description": "Checks the dates and times Claude Code writes into files against the real clock before the write lands.",
-      "version": "0.1.0",
+      "version": "0.1.2",
       "category": "productivity"
     }
   ],

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "date-check",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Checks the dates and times Claude Code writes into changelogs, logs, release notes and handoffs against the real clock before the write lands: a stamp in the future is refused with the real time, a stale one gets a note.",
   "homepage": "https://github.com/nightlab-agent/date-check#readme",
   "repository": "https://github.com/nightlab-agent/date-check",

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.2 (2026-11-01)
+
+- These zone names after a time are now read: UTC, GMT, EST, EDT, CST, CDT, MST, MDT, PST, PDT,
+  CET, CEST, BST, IST (`01:40 EST`, `06:26 UTC`); a time with any other name is taken as local
+  time. A name used in more than one place (`CST`, `IST`, `BST`) is judged by every place it
+  can mean. Before,
+  `01:40 EST` was taken as local time, so a stamp 14 minutes ahead in New York on the night the
+  clocks went back got only a note that it was old, not a refusal.
+- The hour the clocks go back over: a local time in it (01:00 to 02:00 in New York on
+  2026-11-01) can mean two moments, and is now refused only when both are ahead, and noted
+  only when both are old.
+  Before, a line written at the real time in that hour could get a note calling it an hour old.
+- Messages give the real time with its UTC offset (`2026-11-01 01:26 local time, UTC-05:00`).
+- Tests: a log entry written late, with an earlier time than the line above it, is judged against
+  the clock alone (a note when it is over 30 minutes old), and the newer line is not judged again.
+
+## 0.1.1 (2026-10-31)
+
+- README: says what each install scope means, and what the one hook is and when Claude Code runs it. No change
+  to the code.
+
 ## 0.1.0 (2026-10-31)
 
 - First version: before a Write, an Edit, or a shell command that writes to a file, finds the date and time stamps

package/README.md

@@ -41,8 +41,14 @@ screen.
   `.text`, `.rst`, `.adoc`, `.asciidoc`, `.org`, `.log`, and `CHANGELOG`, `HISTORY`, `NEWS`, `RELEASES`,
   `NOTES` with no extension). A date in code is data, not a stamp.
 - Dates are found as `YYYY-MM-DD`, with an optional time and zone
-  (`2026-10-31 16:05`, `2026-10-31T20:05Z`). Other formats (`Oct 31, 2026`) are
-  not checked yet.
+  (`2026-10-31 16:05`, `2026-10-31T20:05Z`, `2026-10-31 16:05 EST`); a bare `16:05`
+  or `16:05 EST` counts at the start of a line in a file named for the day
+  (`log/2026-10-31.md`). Other formats (`Oct 31, 2026`) are not checked yet.
+- Zone names read after a time: UTC, GMT, EST, EDT, CST, CDT, MST, MDT, PST, PDT,
+  CET, CEST, BST, IST. A time with any other name, or none, is your local time.
+  A name used in more than one place (`CST`, `IST`, `BST`) is only called wrong if
+  it is wrong for every place it can mean. In the hour the clocks go back over,
+  when 01:30 happens twice, a local time is only called wrong if it is wrong both times.
 - It checks Write, Edit, and shell commands where `echo` or `printf` writes to
   a file with `>>`, `>` or `| tee`, or `cat` or `tee` writes a heredoc to one.
 
@@ -50,6 +56,14 @@ Settings (asked when you enable the plugin): minutes ahead allowed (2), minutes
 behind before a note (30), days behind before a note (1), notes on old stamps
 (on).
 
+![Claude Code refused a log line stamped 01:58 EST at 01:39 EST by date-check, with the real time and its UTC offset, and Claude asked whether the stamp was meant as EST or EDT](https://raw.githubusercontent.com/nightlab-agent/date-check/003f73177b78ef78659626e8cacbf06d1ab5753d/docs/preview-zone.png)
+
+Seen in a Claude Code 2.1.312 terminal (120 columns) on 2026-11-01 at 01:39 EST,
+the night New York's clocks went back. Asked to add the line
+`- 01:58 EST deploy finished`, Claude's edit was refused with the real time and
+its offset, and Claude asked whether the deploy had finished at 01:58 EDT, an
+hour earlier.
+
 ## What it writes
 
 Nothing. It reads the file a Write or an Edit is about to change, to judge only the new
@@ -57,7 +71,8 @@ lines. Nothing leaves your machine through this mod: it makes no network calls.
 
 ## How it works
 
-- `tool.call` on Write, Edit and Bash: finds the stamps the call adds, compares
+- One hook, `tool.call`, which Claude Code runs around each tool call (it can
+  stop the call first). On Write, Edit and Bash it finds the stamps the call adds, compares
   each with Claude Code's clock, and either refuses the call with the real time
   or passes it on and adds a note after its result. A failure of the mod itself
   never stops the call.
@@ -70,7 +85,9 @@ One line at the Claude Code prompt:
 /plugin install date-check --marketplace nightlab-agent/date-check
 ```
 
-Answer `y` to add the marketplace, then pick a scope. The same from a shell:
+Answer `y` to add the marketplace, then pick a scope (`user`: every project
+of yours; `project`: everyone who opens this repo; `local`: this repo, only
+you; [scopes](https://code.claude.com/docs/en/discover-plugins#choose-an-install-scope)). The same from a shell:
 
 ```
 claude plugin install date-check --marketplace nightlab-agent/date-check

package/hooks/register.tsx

@@ -78,11 +78,11 @@ const quote = (v: Verdict) => `"${v.stamp.text}" (in: ${v.stamp.line})`
 
 export const refusal = (vs: Verdict[]) =>
   `date-check: ${vs.map(quote).join('; ')} ${vs.length === 1 ? 'is' : 'are'} in the future. ` +
-  `It is ${vs[0]!.real} now (local time). Write the real date and time, or leave the stamp out. ` +
+  `It is ${vs[0]!.real} now. Write the real date and time, or leave the stamp out. ` +
   `If a future date is meant (a deadline, a planned release), write the same text again and it goes through.`
 
 export const staleNote = (vs: Verdict[]) =>
-  `date-check: ${vs.map(quote).join('; ')} ${vs.length === 1 ? 'is' : 'are'} older than now (${vs[0]!.real}, local time). ` +
+  `date-check: ${vs.map(quote).join('; ')} ${vs.length === 1 ? 'is' : 'are'} older than now (${vs[0]!.real}). ` +
   `If ${vs.length === 1 ? 'it records' : 'they record'} something past, leave ${vs.length === 1 ? 'it' : 'them'}; if ${vs.length === 1 ? 'it was' : 'they were'} meant as now, correct ${vs.length === 1 ? 'it' : 'them'}.`
 
 export const register: Register = (on, options: Options = {}) => {

package/hooks/stamps.ts

@@ -19,30 +19,52 @@ export type Stamp = {
   minutes?: number
   /** A UTC offset in minutes when it carries one (`Z` is 0). */
   offset?: number
+  /** A zone name written after the time (`EST`, `UTC`), when it carries one. */
+  zone?: string
 }
 
 export type Verdict = { stamp: Stamp; kind: 'future' | 'stale'; real: string }
 
 const DATE = String.raw`(\d{4})-(\d{2})-(\d{2})`
-const TIME = String.raw`(?:[T ](\d{2}):(\d{2})(?::\d{2}(?:\.\d+)?)?\s?(Z|[+-]\d{2}:?\d{2})?)?`
+const NAMED = String.raw`(?:(?:UTC|GMT)[+-]\d{1,2}(?::?\d{2})?(?![\d:])|(?:Z|UTC|GMT|CEST|CET|BST|IST|[ECMP][SD]T)(?![A-Za-z\d+-]))`
+const ZONE = String.raw`([+-]\d{2}:?\d{2}|` + NAMED + ')'
+const TIME = String.raw`(?:[T ](\d{2}):(\d{2})(?::\d{2}(?:\.\d+)?)?\s?` + ZONE + String.raw`?)?`
 const STAMP = DATE + TIME
 const LABEL = String.raw`(?:date|dated|updated|last[ _-]?updated|last[ _-]?modified|modified|released|release[ _-]?date|generated|written|created|as of|timestamp)`
 
 const heading = new RegExp(String.raw`^\s{0,3}#{1,6}\s.*?(?<![\d-])` + STAMP + String.raw`(?![\d-])`)
 const field = new RegExp(String.raw`^\s{0,3}(?:[-*+]\s+|>\s*|\|\s*)?[*_]*` + LABEL + String.raw`\**\s*[:=]\s*\**["'\x60]?(?:on\s)?` + STAMP + String.raw`(?![\d-])`, 'i')
 const opening = new RegExp(String.raw`^\s*(?:[-*+]\s+|>\s*)?[\[(]?` + STAMP + String.raw`(?![\d-])`)
-const timeOpening = /^\s*(?:[-*+]\s+|>\s*)?[\[(]?(\d{2}):(\d{2})(?::\d{2})?(?![\d:])[\])]?(?:\s|$|[,;|-])/
+const timeOpening = new RegExp(String.raw`^\s*(?:[-*+]\s+|>\s*)?[\[(]?(\d{2}):(\d{2})(?::\d{2})?(?![\d:])(?:\s?(` + NAMED + String.raw`))?[\])]?(?:\s|$|[,;|-])`)
+
+/**
+ * The UTC offsets in minutes a zone name can mean. A name used for two zones (CST is
+ * Chicago's winter and China's) has both: a stamp is only called wrong when it is wrong
+ * under every reading.
+ */
+const ZONES: Record<string, number[]> = {
+  UTC: [0], GMT: [0], EST: [-300], EDT: [-240], CST: [-360, 480], CDT: [-300], MST: [-420], MDT: [-360],
+  PST: [-480], PDT: [-420], CET: [60], CEST: [120], BST: [60, 360], IST: [330, 60, 120],
+}
 
 const valid = (y: number, m: number, d: number) => {
   if (m < 1 || m > 12 || d < 1) return false
   return d <= new Date(Date.UTC(y, m, 0)).getUTCDate()
 }
 
-const offsetOf = (z: string | undefined) => {
-  if (z === undefined) return undefined
+/** A UTC offset in minutes (`Z`, `+02:00`, `UTC+2`, `GMT-03:30`); undefined when it is not a real one. */
+const offsetOf = (z: string) => {
   if (z === 'Z') return 0
-  const m = /^([+-])(\d{2}):?(\d{2})$/.exec(z)!
-  return (m[1] === '-' ? -1 : 1) * (Number(m[2]) * 60 + Number(m[3]))
+  const m = /^(?:UTC|GMT)?([+-])(\d{1,2}):?(\d{2})?$/.exec(z)
+  if (!m || Number(m[2]) > 14 || !['00', '15', '30', '45', undefined].includes(m[3])) return undefined
+  return (m[1] === '-' ? -1 : 1) * (Number(m[2]) * 60 + Number(m[3] ?? 0))
+}
+
+/** Daylight time in the United States: the second Sunday of March to the first Sunday of November. */
+const usDaylight = (date: string) => {
+  const [y, m, d] = date.split('-').map(Number) as [number, number, number]
+  const sunday = (month: number, nth: number) => { const first = new Date(Date.UTC(y, month, 1)).getUTCDay(); return 1 + ((7 - first) % 7) + 7 * (nth - 1) }
+  return (m > 3 || (m === 3 && d >= sunday(2, 2))) && (m < 11 || (m === 11 && d < sunday(10, 1)))
 }
 
 const build = (m: RegExpExecArray, at: number, line: string, where: Stamp['where']): Stamp | undefined => {
@@ -53,7 +75,15 @@ const build = (m: RegExpExecArray, at: number, line: string, where: Stamp['where
   if (minutes !== undefined && (Number(hh) > 23 || Number(mm) > 59)) return undefined
   const date = `${m[at]}-${m[at + 1]}-${m[at + 2]}`
   const text = m[0].slice(m[0].indexOf(date)).replace(/[\])"'\x60*]+$/, '').trim()
-  return { text, line: line.trim().slice(0, 120), where, date, ...(minutes !== undefined ? { minutes } : {}), ...(m[at + 5] !== undefined ? { offset: offsetOf(m[at + 5]) } : {}) }
+  return { text, line: line.trim().slice(0, 120), where, date, ...(minutes !== undefined ? { minutes } : {}), ...zoneOf(m[at + 5]) }
+}
+
+const zoneOf = (written: string | undefined) => {
+  if (written === undefined) return {}
+  const z = written.toUpperCase()
+  if (ZONES[z]) return { zone: z }
+  const offset = offsetOf(z)
+  return offset === undefined ? {} : { offset }
 }
 
 /** A `YYYY-MM-DD` date in a file's name (logs/2026-10-31.md), the day its bare line times belong to. */
@@ -72,7 +102,7 @@ const lineStamp = (line: string, fileDate?: string): Stamp | undefined => {
   if ((m = field.exec(line))) return build(m, 1, line, 'field')
   if ((m = opening.exec(line))) return build(m, 1, line, 'line-start')
   if (fileDate && (m = timeOpening.exec(line)) && Number(m[1]) < 24 && Number(m[2]) < 60)
-    return { text: `${m[1]}:${m[2]}`, line: line.trim().slice(0, 120), where: 'line-start', date: fileDate, minutes: Number(m[1]) * 60 + Number(m[2]) }
+    return { text: `${m[1]}:${m[2]}${m[3] ? ` ${m[3]}` : ''}`, line: line.trim().slice(0, 120), where: 'line-start', date: fileDate, minutes: Number(m[1]) * 60 + Number(m[2]), ...zoneOf(m[3]) }
   return undefined
 }
 
@@ -123,18 +153,38 @@ export const dayOf = (ms: number, offset?: number) => {
     ? `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
     : `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`
 }
-/** The local time now as a person writes it: `2026-10-31 16:42`. */
+/**
+ * The local time now as a person writes it, with its offset so that the hour the clocks go back
+ * over is not read twice: `2026-10-31 16:42 local time, UTC-04:00`.
+ */
 export const nowText = (ms: number) => {
   const d = new Date(ms)
-  return `${dayOf(ms)} ${pad(d.getHours())}:${pad(d.getMinutes())}`
+  const o = -d.getTimezoneOffset()
+  const zone = `UTC${o < 0 ? '-' : '+'}${pad(Math.floor(Math.abs(o) / 60))}:${pad(Math.abs(o) % 60)}`
+  return `${dayOf(ms)} ${pad(d.getHours())}:${pad(d.getMinutes())} local time, ${zone}`
 }
 
-/** The moment a stamp names, in ms: its zone when it carries one, the local zone when not. */
-const momentOf = (s: Stamp) => {
+/** The local zone's UTC offset in minutes at a moment (New York in winter: -300). */
+export type ZoneAt = (ms: number) => number
+const localZone: ZoneAt = ms => -new Date(ms).getTimezoneOffset()
+
+/**
+ * The moments a stamp can name, in ms: one for an offset; one per reading of a zone name; and
+ * for a local time, both when it falls in the hour the clocks go back over (01:30 happens twice
+ * that night in New York), one otherwise.
+ */
+const momentsOf = (s: Stamp, zoneAt: ZoneAt) => {
   const [y, m, d] = s.date.split('-').map(Number) as [number, number, number]
-  const min = s.minutes ?? 0
-  if (s.offset !== undefined) return Date.UTC(y, m - 1, d, 0, min) - s.offset * 60000
-  return new Date(y, m - 1, d, 0, min).getTime()
+  const wall = Date.UTC(y, m - 1, d, 0, s.minutes ?? 0)
+  if (s.offset !== undefined) return [wall - s.offset * 60000]
+  if (s.zone) {
+    // "EST" is often written for Eastern time all year: in summer it can also mean EDT.
+    const loose = /^[ECMP]ST$/.test(s.zone) && usDaylight(s.date) ? [ZONES[s.zone]![0]! + 60] : []
+    return [...ZONES[s.zone]!, ...loose].map(o => wall - o * 60000)
+  }
+  const offsets = [...new Set([zoneAt(wall - 12 * 3600000), zoneAt(wall + 12 * 3600000)])]
+  const fits = offsets.filter(o => zoneAt(wall - o * 60000) === o)
+  return (fits.length ? fits : offsets.slice(0, 1)).map(o => wall - o * 60000)
 }
 
 export type Limits = { aheadMinutes: number; staleMinutes: number; staleDays: number }
@@ -145,8 +195,10 @@ export const LIMITS: Limits = { aheadMinutes: 2, staleMinutes: 30, staleDays: 1
  * locally and in UTC (a UTC date written in the evening west of Greenwich is not wrong); stale
  * when more than `staleDays` before today. A time is in the future when more than
  * `aheadMinutes` ahead of now; stale when more than `staleMinutes` behind it on the same day.
+ * A time that can mean two moments is judged by both: future only when both are ahead, stale
+ * only when both are behind.
  */
-export const judge = (stamps: Stamp[], now: number, limits: Limits = LIMITS): Verdict[] => {
+export const judge = (stamps: Stamp[], now: number, limits: Limits = LIMITS, zoneAt: ZoneAt = localZone): Verdict[] => {
   const real = nowText(now)
   const today = dayOf(now)
   const todayUtc = dayOf(now, 0)
@@ -162,10 +214,11 @@ export const judge = (stamps: Stamp[], now: number, limits: Limits = LIMITS): Ve
       }
       continue
     }
-    const at = momentOf(s)
-    if (at > now + limits.aheadMinutes * 60000) out.push({ stamp: s, kind: 'future', real })
+    const moments = momentsOf(s, zoneAt)
+    const at = Math.max(...moments)
+    if (Math.min(...moments) > now + limits.aheadMinutes * 60000) out.push({ stamp: s, kind: 'future', real })
     else if (at < now - limits.staleMinutes * 60000) {
-      const days = s.offset === undefined ? s.date === today : dayOf(at) === today
+      const days = s.offset === undefined && !s.zone ? s.date === today : dayOf(at) === today
       if (days || (now - at) / 86400000 > limits.staleDays) out.push({ stamp: s, kind: 'stale', real })
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nightlab-agent/date-check",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Claude Code mod: checks the dates and times Claude Code writes into changelogs, logs, release notes and handoffs against the real clock before the write lands; a stamp in the future is refused with the real time.",
   "keywords": [
     "claude-code",