@nightlab-agent/date-check 0.1.4 → 0.1.5

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "date-check",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "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,25 @@
 # Changelog
 
+## 0.1.5 (2026-11-02)
+
+- A future date written as a release heading is refused even when the line the edit removes
+  named that date in a sentence ("Release planned for 2026-11-05" edited into
+  "## [1.0.0] - 2026-11-05"). Before, any new stamp whose text appeared anywhere in a removed
+  line was taken as carried over; now only a removed line's own stamp is.
+- A new file named for a past day is refused in each folder. Before, the "write it again"
+  memory was kept by the file name alone, so a refusal for `log/2025-06-12.md` let a
+  different new `journal/2025-06-12.md` through unasked.
+- A future stamp refused in a Write and written again by the shell with a relative path
+  (`echo ... >> notes.md`) now goes through as the refusal promises. Before, the retry was
+  matched by the path as typed, so the relative spelling was refused a second time. Both
+  checks now join a relative path to the session's directory and resolve `.` and `..`; on
+  Windows, `E:\p\notes.md` and a relative `notes.md` from `E:\p` are one file. A relative
+  path after a `cd` in the same command (in parentheses too) is the same file only after the
+  same `cd`. Network paths (`\\srv\share`) match in any letter case, as drive paths do.
+- A date moved out of a code block into the text is judged. Before, the line counted as one
+  the file already had, so a sample heading in a fence turned into a real heading dated in
+  the future went through.
+
 ## 0.1.4 (2026-11-02)
 
 - Every prompt now carries the clock, so Claude knows the time instead of guessing it: the

package/README.md

@@ -33,8 +33,9 @@ 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.
+back as `- 02:11 release went out`. Claude has been seen guessing a time on its
+own (17:23, taken from a folder name, close enough to pass); date-check catching
+a wrong guess Claude made on its own has not yet been seen on a screen.
 
 ![With date-check telling Claude the time on each prompt, Claude wrote a log line starting 05:54 at 05:54 without running a command, then named the day, the time zone and how long ago the previous message came](https://raw.githubusercontent.com/nightlab-agent/date-check/1f80c3f7744ebb8d6edab7dfb767d82b42cb2e5b/docs/preview-clock.png)
 
@@ -101,7 +102,7 @@ was filled in from the clock as the file was written.
 
 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).
+(on), the clock on every prompt (on), fill placeholders (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)
 

package/hooks/register.tsx

@@ -58,6 +58,40 @@ export const shellWrite = (command: string): { file: string; text: string } | un
   return file === undefined ? undefined : { file, text: texts.join('\n') }
 }
 
+/** The directory changes in a shell command (`cd a`, `(pushd b`): after one, a relative path means no one place. */
+const dirMoves = (command: string) =>
+  [...command.matchAll(/(?:^|[;&|\n({]\s*)(cd|pushd)\s+([^;&|\n)}]*)/g)].map(m => `${m[1]} ${m[2]!.trim()}`)
+const movesDir = (command: string) => dirMoves(command).length > 0
+
+/** The file as one spelling, for remembering what was refused: a relative path joined to the
+ * session's directory, `.` and `..` resolved, one separator, a drive letter's path in lower
+ * case, a network path in lower case. A relative path after a `cd` in the same command is kept
+ * with the `cd`s before it, so it is one file only with the same moves; `~` and a failed reading
+ * stay as written. */
+async function placed($: EngineInterface, file: string, moves: string[] = []): Promise<string> {
+  if (!file || file.startsWith('~')) return file
+  const absolute = /^(?:[\\/]|[A-Za-z]:[\\/])/.test(file)
+  if (!absolute && moves.length) return `${moves.join('; ')}; ${file}`
+  let full = file
+  if (!absolute) {
+    try {
+      full = `${await $.session.cwd()}/${file}`
+    } catch {
+      return file
+    }
+  }
+  const drive = /^[A-Za-z]:/.exec(full)?.[0] ?? ''
+  const parts: string[] = []
+  for (const part of full.slice(drive.length).split(/[\\/]+/)) {
+    if (part === '' || part === '.') continue
+    if (part === '..') parts.pop()
+    else parts.push(part)
+  }
+  const network = /^[\\/]{2}/.test(full)
+  const one = `${network ? '//' : drive}/${parts.join('/')}`.replace(/^\/\/\//, '//')
+  return drive || network ? one.toLowerCase() : one
+}
+
 /** 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; created?: boolean }> {
   const none = { file: '', before: '', after: '' }
@@ -80,7 +114,7 @@ async function change($: EngineInterface, x: Call): Promise<{ file: string; befo
     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)
+    const sure = !w.file.startsWith('~') && !movesDir(x.command)
     return { file: w.file, before: '', after: w.text, created: sure && !(await $.fs.exists(w.file)) }
   }
   return none
@@ -206,11 +240,13 @@ export const register: Register = (on, options: Options = {}) => {
       name = undefined
     }
     // Keyed by the line as the agent wrote it, so a retry with the same placeholder a minute later is the same line.
-    const key = (v: Verdict) => `${file}\n${unfill(v.stamp.line, filled)}`
+    const at = await placed($, file, x.tool === 'Bash' && typeof x.command === 'string' ? dirMoves(x.command) : [])
+    const key = (v: Verdict) => `${at}\n${unfill(v.stamp.line, filled)}`
     const future = verdicts.filter(v => v.kind === 'future')
     const fresh = future.filter(v => !((meant.get(key(v)) ?? Infinity) < began))
-    // 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()}`
+    // By the placed path, so a retry spelled another way (relative, absolute) is the same file
+    // and a file of the same name in another folder is not.
+    const nameKey = `(name)\n${at}`
     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.

package/hooks/stamps.ts

@@ -106,27 +106,64 @@ const lineStamp = (line: string, fileDate?: string): Stamp | undefined => {
   return undefined
 }
 
+/** For each line, whether it sits in a code fence that is closed (a fence left open to the end is not counted). */
+const closedFences = (lines: string[]): boolean[] => {
+  const inside: boolean[] = []
+  let open = -1
+  for (const [i, l] of lines.entries()) {
+    if (/^\s*(```|~~~)/.test(l)) open = open < 0 ? i : -1
+    inside.push(open >= 0 || (/^\s*(```|~~~)/.test(l) && open < 0))
+  }
+  if (open >= 0) for (let i = open; i < lines.length; i++) inside[i] = false
+  return inside
+}
+
 /**
  * The stamps a change adds: the stamps on lines of `after` that `before` did not have, read
  * in the whole of `after` (so a line inside a code block the file already had is seen as
  * code). A stamp whose text was on a line the change removes is carried over, not added.
  */
 export const newStamps = (before: string, after: string, fileDate?: string): Stamp[] => {
+  // A line is the same line only in the same place: inside a closed code fence or out of one,
+  // so a sample moved out of a fence into the text is a new line, and closing a fence left open
+  // does not make every line under it new.
   const had = new Map<string, number>()
-  for (const l of before.split(/\r?\n/)) had.set(l, (had.get(l) ?? 0) + 1)
+  const beforeIn = closedFences(before.split(/\r?\n/))
+  before.split(/\r?\n/).forEach((l, i) => {
+    const k = `${beforeIn[i] ? '`' : ' '}${l}`
+    had.set(k, (had.get(k) ?? 0) + 1)
+  })
   const out: Stamp[] = []
+  const kept: string[] = []
+  const lines = after.split(/\r?\n/)
+  const afterIn = closedFences(lines)
   let fence = false
-  for (const line of after.split(/\r?\n/)) {
-    const n = had.get(line) ?? 0
+  for (const [i, line] of lines.entries()) {
+    const isFence = /^\s*(```|~~~)/.test(line)
+    if (isFence) fence = !fence
+    const k = `${afterIn[i] ? '`' : ' '}${line}`
+    const n = had.get(k) ?? 0
     const isNew = n === 0
-    if (!isNew) had.set(line, n - 1)
-    if (/^\s*(```|~~~)/.test(line)) { fence = !fence; continue }
-    if (fence || !isNew || indentedCode(line)) continue
+    if (!isNew) had.set(k, n - 1)
+    if (isFence) continue
+    if (fence || indentedCode(line)) continue
     const s = lineStamp(line, fileDate)
-    if (s) out.push(s)
+    if (s) (isNew ? out.push(s) : kept.push(s.text))
+  }
+  // Only a stamp the old text itself had carries over, read in the old text's own context (a
+  // date named in a removed sentence or code block is not one): the old text's stamps less those
+  // still on its unchanged lines.
+  const carried = new Map<string, number>()
+  if (before) {
+    for (const s of newStamps('', before, fileDate)) carried.set(s.text, (carried.get(s.text) ?? 0) + 1)
+    for (const s of kept) carried.set(s, (carried.get(s) ?? 0) - 1)
   }
-  const removed = [...had.entries()].filter(([, n]) => n > 0).map(([l]) => l).join('\n')
-  return out.filter(s => !removed.includes(s.text))
+  return out.filter(s => {
+    const n = carried.get(s.text) ?? 0
+    if (n <= 0) return true
+    carried.set(s.text, n - 1)
+    return false
+  })
 }
 
 /** The stamps in some lines of text. */

package/package.json

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