@nightlab-agent/date-check 0.1.1 → 0.1.3

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.1",
+      "version": "0.1.3",
       "category": "productivity"
     }
   ],

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "date-check",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",
@@ -31,7 +31,7 @@
     "staleDays": {
       "type": "number",
       "title": "Days behind before a note",
-      "description": "A written date more than this many days before today gets a note.",
+      "description": "A written date more than this many days before today gets a note; a new file named for such a day is refused once.",
       "default": 1
     },
     "staleNotes": {

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.1.3 (2026-11-01)
+
+- A new Markdown or text file whose name carries a date more than a day before today
+  (`briefs/daily-brief-2025-06-12.md` created on 2026-11-01) is refused once, with the real
+  date. If that date is meant (a record of that day), Claude writes the same file again and it
+  goes through. A name with today's date, yesterday's or a later day's (a plan) is not judged,
+  nor a file that already exists, nor a date in a folder's name. The days allowed follow the
+  "days behind" setting. Before, only the stamps inside a file were checked, never its name.
+
+## 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

package/README.md

@@ -17,9 +17,16 @@ Seen in a Claude Code 2.1.312 terminal (120 columns) on 2026-10-31 at 16:52.
 Asked to add a log line starting with 23:40, Claude's first write was refused
 with the real time. Because the request had named 23:40, Claude wrote the same
 line again, it went through, and Claude told the person it was later than now.
-The same happened with a changelog entry dated 2026-11-03. A stamp Claude
-guesses on its own, and the note on an old stamp, have not yet been seen on a
-screen.
+The same happened with a changelog entry dated 2026-11-03.
+
+![Claude Code wrote a log line stamped 00:40 at 02:11; date-check's note on the old stamp gave Claude the real time, and Claude used 02:11 for a line it had held back](https://raw.githubusercontent.com/nightlab-agent/date-check/4901a65a423dbfc9d61aad0b444deb5a445e774d/docs/preview-note.png)
+
+Seen on 2026-11-01 at 02:11 EST, same terminal. Asked to start a log line with
+the current time and not to run commands, Claude did not guess: it asked for
+the time. Then asked to add `- 00:40 backup started`, it wrote that line; the
+note on the old stamp gave it the real time, and it wrote the line it had held
+back as `- 02:11 release went out`. A stamp Claude guesses on its own has not
+yet been seen on a screen.
 
 - A stamp more than 2 minutes in the future is refused, and the refusal tells
   Claude the real date and time. If the future date is meant (a deadline, a
@@ -27,6 +34,11 @@ screen.
 - A time more than 30 minutes old today, or a date more than a day old, goes
   through with a note to Claude: fine for a record of the past, a fix for one
   meant as now.
+- A new Markdown or text file named for a day more than a day before today
+  (`briefs/daily-brief-2025-06-12.md`, created on 2026-11-01) is refused once
+  with the real date. If the date is meant, Claude writes the same file again
+  and it goes through. Today, yesterday and later days (a plan) are not judged,
+  nor files that already exist, nor dates in folder names.
 - What counts as a stamp: a date in a Markdown heading (`## 0.2.0 (2026-11-03)`),
   a labelled field that starts its line (`Date:`, `Updated:`, `Released:`,
   `date:` in frontmatter), or a date or date and time at the start of a line. A
@@ -41,8 +53,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 +68,22 @@ 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.
+
+![Claude Code's write of briefs/daily-brief-2025-06-12.md refused by date-check with the real date; Claude wrote it again because the name was given, then said the date was likely wrong and offered today's name](https://raw.githubusercontent.com/nightlab-agent/date-check/e008e44b11e50b3115766b19c489e199b7f94ed1/docs/preview-name.png)
+
+Seen in the same terminal on 2026-11-01 at 02:23 EST. Asked to create today's
+brief as `briefs/daily-brief-2025-06-12.md`, Claude's first write was refused
+with the real date. Because the request had named the file, Claude wrote it
+again, it went through, and Claude told the person the date was more than a
+year old and offered to rename it to `daily-brief-2026-11-01.md`.
+
 ## What it writes
 
 Nothing. It reads the file a Write or an Edit is about to change, to judge only the new

package/hooks/register.tsx

@@ -1,5 +1,5 @@
 import type { EngineInterface, Register } from 'claude-code'
-import { dateOfFile, dayOf, judge, LIMITS, newStamps } from './stamps'
+import { dateOfFile, dayOf, judge, judgeName, LIMITS, newStamps } from './stamps'
 import type { Limits, Verdict } from './stamps'
 
 // date-check, the hooks module. Before a Write, an Edit, or a shell command that appends to
@@ -9,6 +9,8 @@ import type { Limits, Verdict } from './stamps'
 //   the same line written to the same file a second time goes through (a deadline or a plan
 //   can be in the future on purpose), with a note;
 // - a stamp older than the limits goes through with a note the agent reads after the result.
+// - a new file whose name carries a day more than staleDays past (logs/2025-06-12.md written
+//   on 2026-11-01) is refused once with the real date, the same way; a later day is a plan.
 // Lines the file already had are never judged: only what this call adds. Only Markdown and
 // text files (isText): a date in code is data, not a stamp.
 
@@ -52,11 +54,12 @@ export const shellWrite = (command: string): { file: string; text: string } | un
 }
 
 /** What a call changes in which file: the file's text before and after it. */
-async function change($: EngineInterface, x: Call): Promise<{ file: string; before: string; after: string }> {
+async function change($: EngineInterface, x: Call): Promise<{ file: string; before: string; after: string; created?: boolean }> {
   const none = { file: '', before: '', after: '' }
   if (x.tool === 'Write' && typeof x.content === 'string' && x.file_path) {
-    const before = (await $.fs.exists(x.file_path)) ? await $.fs.read(x.file_path) : ''
-    return { file: x.file_path, before, after: x.content }
+    const exists = await $.fs.exists(x.file_path)
+    const before = exists ? await $.fs.read(x.file_path) : ''
+    return { file: x.file_path, before, after: x.content, created: !exists }
   }
   if (x.tool === 'Edit' && typeof x.new_string === 'string' && typeof x.old_string === 'string' && x.file_path) {
     const before = (await $.fs.exists(x.file_path)) ? await $.fs.read(x.file_path) : ''
@@ -69,7 +72,11 @@ async function change($: EngineInterface, x: Call): Promise<{ file: string; befo
   }
   if (x.tool === 'Bash' && typeof x.command === 'string') {
     const w = shellWrite(x.command)
-    return w ? { file: w.file, before: '', after: w.text } : none
+    if (!w) return none
+    // Whether the shell's file is new is only known when its path means one place: not under
+    // `~` (the engine does not expand it) and not after a `cd` in the same command.
+    const sure = !w.file.startsWith('~') && !/(?:^|[;&|\n]\s*)(?:cd|pushd)\s/.test(x.command)
+    return { file: w.file, before: '', after: w.text, created: sure && !(await $.fs.exists(w.file)) }
   }
   return none
 }
@@ -78,11 +85,16 @@ 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 nameRefusal = (file: string, n: { date: string; real: string }) =>
+  `date-check: the new file's name says ${n.date} (${file.split(/[/\\]/).pop()}), a day that has passed. ` +
+  `It is ${n.real} now. If the file is for today, name it for today. ` +
+  `If that date is meant (a record of that day), write the same file 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 = {}) => {
@@ -103,11 +115,13 @@ export const register: Register = (on, options: Options = {}) => {
     if (x.tool !== 'Write' && x.tool !== 'Edit' && x.tool !== 'Bash') return next(e)
     const began = ++order
     let verdicts: Verdict[] = []
+    let name: ReturnType<typeof judgeName>
     let file = ''
     try {
       const now = await $.clock.now()
       const w = await change($, x)
       file = w.file
+      if (file && isText(file) && w.created) name = judgeName(file, now, limits)
       if (file && isText(file) && w.after) {
         // Bare times in a file named for a later day are a plan for that day, not stamps.
         const day = dateOfFile(file)
@@ -116,17 +130,25 @@ export const register: Register = (on, options: Options = {}) => {
     } catch {
       // A failure of this mod never stops the call.
       verdicts = []
+      name = undefined
     }
     const key = (v: Verdict) => `${file}\n${v.stamp.line}`
     const future = verdicts.filter(v => v.kind === 'future')
     const fresh = future.filter(v => !((meant.get(key(v)) ?? Infinity) < began))
-    if (fresh.length) {
-      for (const v of fresh) meant.set(key(v), ++order)
-      return { deny: refusal(fresh) }
+    // By the file's name alone, so a retry spelled another way (relative, absolute) is the same file.
+    const nameKey = `(name)\n${file.split(/[/\\]/).pop()}`
+    const freshName = name && !((meant.get(nameKey) ?? Infinity) < began) ? name : undefined
+    if (fresh.length || freshName) {
+      // The first refusal's number is kept: an older call refused late must not move it past a retry.
+      const mark = (k: string) => { const n = ++order; meant.set(k, Math.min(meant.get(k) ?? Infinity, n)) }
+      for (const v of fresh) mark(key(v))
+      if (freshName) mark(nameKey)
+      return { deny: [...(freshName ? [nameRefusal(file, freshName)] : []), ...(fresh.length ? [refusal(fresh)] : [])].join('\n') }
     }
     const done = await next(e)
     if (done.deny !== undefined || done.isError) return done
     const said = [
+      ...(name ? [`date-check: kept the date ${name.date} in the new file's name as written the second time.`] : []),
       ...(future.length ? [`date-check: kept ${future.map(v => `"${v.stamp.text}"`).join(', ')} as written the second time (a date in the future on purpose).`] : []),
       ...(notes && verdicts.some(v => v.kind === 'stale') ? [staleNote(verdicts.filter(v => v.kind === 'stale'))] : []),
     ]

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,12 +214,26 @@ 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 })
     }
   }
   return out
 }
+
+/**
+ * The date in a new file's name, when it is more than `staleDays` before today: the agent
+ * named the file for the day it guessed, often one near its training. A later day is a plan
+ * (an agenda for 2026-11-05), not judged. `undefined` when the name carries no date or the
+ * date can be today.
+ */
+export const judgeName = (path: string, now: number, limits: Limits = LIMITS): { date: string; real: string } | undefined => {
+  const date = dateOfFile(path)
+  if (!date) return undefined
+  const v = judge([{ text: date, line: path, where: 'field', date }], now, limits)[0]
+  return v?.kind === 'stale' ? { date, real: v.real } : undefined
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nightlab-agent/date-check",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",