rvlib-shipkit 0.22.0 → 0.22.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.22.1
+
+- **Fix: the cache stamp is baked in at RUN time, replays print it verbatim.** 0.22.0 annotated only the REPLAY, so a fresh run and a cache hit rendered different strings and STATUS.md still diffed on every alternation (his catch, the second one on this line). A TTL clean pass now writes "(cached at <stamp> until <stamp>)" into the line once, live output and every replay are byte-identical, and the line changes only when a re-validation happens. Proven: fresh-then-cached runs produce a zero-diff STATUS body.
+
 ## 0.22.0
 
 - **Fix: the machine-row auto-commit could not see STATUS.md.** The git helper trims its whole output, so the FIRST porcelain line loses its leading space and the old column-3 slice read "TATUS.md", making the preflight silently decline the exact dirt it was built to eat. `dirtyPathList` parses status prefixes robustly now (renames and quoted paths included, regression-tested on the trimmed-first-line case), and a decline is never silent: the preflight names the non-machine paths it refused.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.22.0",
+    "version": "0.22.1",
     "description": "All-in-one repo companion: ci gate (task DAG), auto-discovered health checks, release-contract fulfillness, asks queue, md-wiki tools, asset atelier, live tui",
     "license": "MIT",
     "type": "module",

package/src/core/check-suite.ts

@@ -143,13 +143,14 @@ export class CheckSuite {
                 && entry != null && entry.version === r.version && entry.key === key
                 && this.now() - entry.at < r.ttlMs && this.now() >= entry.at
             if (fresh) {
-                // absolute stamp, never "Xm ago": a relative age re-renders on
-                // every run and turns committed STATUS.md checkpoints into
-                // noise diffs (his call 2026-08-05). The line now changes only
-                // when the cache actually refreshes.
-                const lines = entry.lines.map((l, i): Line => (i === 0 ? { ...l, text: `${l.text} (cached ${fmtStamp(entry.at)})` } : l))
-                out.push(...lines)
-                this.onResult?.(r.name, { lines, status: 'pass', cached: true }) // only clean passes are cached
+                // the stamp was baked in when the check RAN (below): a replay
+                // prints the stored lines VERBATIM, so the live run and every
+                // later replay render the same string, and the line changes
+                // only when a re-validation happens (his call 2026-08-05,
+                // second round: annotating replays but not live runs still
+                // diffed on every fresh-vs-cached alternation)
+                out.push(...entry.lines)
+                this.onResult?.(r.name, { lines: entry.lines, status: 'pass', cached: true }) // only clean passes are cached
                 continue
             }
             const t = new CheckCtx(this.toolPaths)
@@ -160,14 +161,18 @@ export class CheckSuite {
                 else if (e instanceof ToolUnresolved) t.note(`${r.name} skipped (${e.message})`)
                 else t.fail(`${r.name} errored (${String(e).slice(0, 200)}) — network down, or a bug in this check`)
             }
-            out.push(...t.lines)
-            this.onResult?.(r.name, { lines: t.lines, status: t.failed ? 'fail' : t.warned ? 'warn' : 'pass', cached: false })
+            // a skip line is an UNKNOWN, not a clean pass — replaying
+            // "registry unreachable" for a TTL asserts a dead network as
+            // fact long after it recovered
+            const cacheable = r.ttlMs > 0 && !t.failed && !t.warned && !t.lines.some((l) => l.kind === 'skip')
+            const lines = cacheable
+                ? t.lines.map((l, i): Line => (i === 0 ? { ...l, text: `${l.text} (cached at ${fmtStamp(this.now())} until ${fmtStamp(this.now() + r.ttlMs)})` } : l))
+                : t.lines
+            out.push(...lines)
+            this.onResult?.(r.name, { lines, status: t.failed ? 'fail' : t.warned ? 'warn' : 'pass', cached: false })
             if (t.failed) anyFail = true
             if (r.ttlMs > 0) {
-                // a skip line is an UNKNOWN, not a clean pass — replaying
-                // "registry unreachable" for a TTL asserts a dead network as
-                // fact long after it recovered
-                if (!t.failed && !t.warned && !t.lines.some((l) => l.kind === 'skip')) { cache[r.name] = { version: r.version, key, at: this.now(), lines: t.lines }; cacheDirty = true }
+                if (cacheable) { cache[r.name] = { version: r.version, key, at: this.now(), lines }; cacheDirty = true }
                 // a WARN/FAIL evicts the stale pass — a later run must re-probe,
                 // not replay an ok recorded before the breakage
                 else if (entry != null) { delete cache[r.name]; cacheDirty = true }