openclaw-diag-cli 1.10.1 → 1.10.3

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## v1.10.3 — regression test: full-cache reuse conclusion-equivalence (2026-06-16)
+
+Test-only release. No runtime change — the shipped package is byte-identical
+to v1.10.2 (the `files` whitelist excludes `tests/`). Tagged to mark the
+correctness verification of the v1.10.2 prefilter cache-reuse path.
+
+### Tests
+- `tests/test_cache_prefilter_reuse.py`: added
+  `test_top30_selection_identical_across_modes_when_enough_dated`. Stages 35
+  dated runs inside the 7d window plus 5 undated runs in an old-mtime file
+  (which the prefilter disk scan drops but the full-cache superset keeps), then
+  proves the top-30 selection (sorted by `started_ts_ms` desc) is IDENTICAL
+  between the full-cache-superset and prefilter-disk modes — so `plugin_diag`'s
+  `latest`/`recent` conclusions are mode-invariant and the only delta is
+  undated runs that never reach the top-30. Confirms full-cache reuse causes
+  no data inaccuracy. Suite: 199 passed, 1 skipped.
+
+
+## v1.10.2 — prefilter requests reuse an existing full-scan cache (2026-06-16)
+
+Performance + docs fix for the `all` command. No behavior change to output
+contents; pure cache-reuse optimization plus a stale-comment correction.
+
+### `collect_runs` prefilter reuse
+
+Before: in `openclaw-diag all`, `configuration` (and `performance`) populate
+the full-scan trajectory cache early, yet `plugin_diag`'s 7d `mtime_prefilter`
+request still hit disk for a fresh windowed scan (~540ms observed) because the
+superset-reuse path explicitly excluded `mtime_prefilter=True` requests.
+
+Now: any windowed request (`since_ms` set, no per-file limit) — INCLUDING
+`mtime_prefilter=True` — is served IN MEMORY from an EXISTING full-scan cache
+when one is present. A prefilter request only falls through to the real
+prefilter DISK scan when NO full cache exists (the standalone fast path). When
+served from the full cache the result is the superset of a prefilter disk scan
+(undated runs in old-mtime files are kept); all current windowed consumers
+tolerate that (gateway counts dated runs only; plugin_diag takes the top-30
+dated runs).
+
+Measured: `plugin_diag` inside `all` dropped from ~540ms to ~100ms. Standalone
+`plugin_diag` is unchanged (still does its 7d/30d prefilter disk scan).
+
+Zero-deviation note: the displayed scope count still equals exactly what was
+consumed in each run. The count may legitimately differ between modes
+(`all` reuses the full-cache superset; standalone uses the prefilter subset),
+but the `7d` window token is identical and each displayed count matches its
+own scan.
+
+### Fixes
+- `ocdiag/core/context.py`: corrected the `collect_runs` docstring — `plugin_diag`
+  is no longer listed as a no-window caller (it has been a windowed 7d→30d
+  prefilter caller since v1.10.0); documented the new prefilter-reuse path and
+  the superset semantics.
+
+### Tests
+- New `tests/test_cache_prefilter_reuse.py` (pytest): proves a prefilter request
+  reuses an existing full cache (same Run objects, no disk re-scan) and that a
+  prefilter request with no full cache does a real disk scan without fabricating
+  a full-scan cache entry. Suite: 198 passed, 1 skipped.
+
+
 ## v1.10.1 — data_scope zero-drift: derive window/counts from actual scan (2026-06-16)
 
 A correctness fix on top of v1.10.0. The owner's hard requirement: the

package/ocdiag/__init__.py

@@ -1,3 +1,3 @@
 """ocdiag — shared library for openclaw-diag-cli scripts."""
 
-__version__ = "1.10.1"
+__version__ = "1.10.3"

package/ocdiag/core/context.py

@@ -92,31 +92,36 @@ class DiagContext:
     ) -> List[Any]:
         """Memoized ``trajectory.collect_runs`` keyed on its arg tuple.
 
-        The five no-window callers (performance.py x2, configuration,
-        plugin_diag, run_health) all share key
+        The no-window callers (performance.py x2, configuration,
+        run_health) all share key
         ``(None, None, False, False)`` — the first call populates the cache,
         the rest are hits. Windowed callers (gateway 24h,
-        cron_jobs/recent_errors 7d, environment 14d) each have a distinct
-        ``since_ms``; in the ``all`` command they reuse the cached full scan
-        via the superset path below (zero disk I/O). ``populate_raw`` MUST be
+        cron_jobs/recent_errors 7d, environment 14d, plugin_diag 7d→30d via
+        ``mtime_prefilter``) each have a distinct ``since_ms``; in the ``all``
+        command they reuse the cached full scan via the superset path below
+        (zero disk I/O), prefilter requests included. ``populate_raw`` MUST be
         in the key — a raw-less cached entry would silently miss raw fields
-        for a raw caller. ``mtime_prefilter`` is keyed too because a
-        prefiltered result is a SUBSET (drops undated runs in old files) and
-        must not pollute the complete-set keys.
+        for a raw caller. ``mtime_prefilter`` is keyed too: a fresh prefilter
+        DISK scan is a SUBSET (drops undated runs in old files) and must not
+        pollute the complete-set keys; a prefilter request served from the
+        full cache instead yields the superset (keeps undated runs).
 
         Two reuse paths, in order:
 
         1) Exact key hit → return shallow copy.
-        2) Superset reuse: a windowed (``since_ms`` is not None,
-           ``limit_per_file is None``, ``mtime_prefilter=False``) request,
+        2) Superset reuse: any windowed request (``since_ms`` is not None,
+           ``limit_per_file is None``), REGARDLESS of ``mtime_prefilter``,
            when a full-scan entry under
            ``(None, None, populate_raw, False)`` already exists, is served
            by filtering that cached list IN MEMORY using the EXACT predicate
            from ``trajectory.collect_runs``: keep iff
-           ``(not r.started_ts_ms) or (r.started_ts_ms >= since_ms)``. The
-           filtered subset is identical (same Run objects, set-equal) to a
-           fresh ``trajectory.collect_runs(files, since_ms=...)``. We cache
-           it under the exact requested key to dedup repeat lookups.
+           ``(not r.started_ts_ms) or (r.started_ts_ms >= since_ms)``. For a
+           non-prefilter request the filtered list is set-equal to a fresh
+           ``trajectory.collect_runs(files, since_ms=...)``; for a prefilter
+           request it is a SUPERSET of the prefilter disk scan (keeps undated
+           runs the mtime floor would have skipped). We cache it under the
+           exact requested key to dedup repeat lookups. A prefilter request
+           only reaches Path 3 when NO full scan is cached (standalone path).
         3) Disk scan fall-through. When ``mtime_prefilter=True`` and
            ``since_ms`` is not None, only files whose mtime is at or after
            ``since_ms - _MTIME_PREFILTER_GRACE_MS`` are scanned (the grace
@@ -139,14 +144,20 @@ class DiagContext:
         if cached is not None:
             return list(cached)
 
-        # Path 2: superset reuse — a windowed query (no per-file limit, no
-        # prefilter) can be served from a cached full scan with the same
-        # ``populate_raw``. Predicate mirrors trajectory.collect_runs exactly,
-        # INCLUDING keeping undated runs (started_ts_ms == 0).
+        # Path 2: superset reuse — any windowed query (no per-file limit) can
+        # be served from a cached full scan with the same ``populate_raw``,
+        # INCLUDING prefilter requests. We only reuse an EXISTING full cache;
+        # a prefilter request with no full cache falls through to the Path 3
+        # fast disk scan (the standalone path). When a prefilter request is
+        # served here it yields the SUPERSET of a prefilter disk scan (keeps
+        # undated runs the mtime floor would skip) — all current windowed
+        # consumers tolerate that (gateway counts dated runs only; plugin_diag
+        # takes the top-30 dated runs). Predicate mirrors
+        # trajectory.collect_runs exactly, INCLUDING keeping undated runs
+        # (started_ts_ms == 0).
         if (
             since_ms is not None
             and limit_per_file is None
-            and not mtime_prefilter
         ):
             full_key = (None, None, populate_raw, False)
             full_cached = self._trajectory_cache.get(full_key)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-diag-cli",
-  "version": "1.10.1",
+  "version": "1.10.3",
   "description": "OpenClaw observer-only diagnostic CLI. Zero-dependency Python scripts wrapped in Node for npx-friendly install.",
   "keywords": [
     "openclaw",