@dogfood-lab/findings 1.2.2 → 1.3.0

package/lib/rename-with-retry.js

@@ -16,6 +16,13 @@
  * appender) are themselves synchronous, and Promise-based retries would
  * leak the async boundary into otherwise-deterministic flush paths.
  *
+ * D1B-002-findings — the backoff used to be a CPU-busy `while (Date.now() <
+ * until)` spin. The repo already ships `sleepSync` via `Atomics.wait` on a
+ * tiny SharedArrayBuffer (see `file-lock.js:286`). Atomics.wait yields the
+ * thread instead of pegging a core, with the same sync API. The retry
+ * envelope and visible behaviour are preserved; only the cost of the wait
+ * changes.
+ *
  * @param {string} tmp - Source path (the just-written temp file).
  * @param {string} dest - Destination path (the canonical artifact).
  * @param {object} [opts]
@@ -25,6 +32,24 @@
  */
 import { renameSync } from 'node:fs';
 
+/**
+ * Sleep synchronously for `ms` milliseconds via `Atomics.wait` on a tiny
+ * SharedArrayBuffer. Yields the thread (does not spin). Mirrors the
+ * `sleepSync` in `file-lock.js:286` — the contract is identical; the
+ * helper is duplicated here because rename-with-retry must not import the
+ * larger file-lock module (cyclic-import risk: atomic-write imports
+ * rename-with-retry, and file-lock imports atomic-write transitively
+ * through the lock-event write path).
+ *
+ * @param {number} ms
+ */
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  const sab = new SharedArrayBuffer(4);
+  const view = new Int32Array(sab);
+  Atomics.wait(view, 0, 0, ms);
+}
+
 export function renameWithRetry(tmp, dest, { retries = 10, baseMs = 15, maxMs = 200 } = {}) {
   for (let i = 0; i <= retries; i++) {
     try {
@@ -33,11 +58,10 @@ export function renameWithRetry(tmp, dest, { retries = 10, baseMs = 15, maxMs =
     } catch (err) {
       if ((err.code !== 'EPERM' && err.code !== 'EBUSY') || i === retries) throw err;
       const delay = Math.min(baseMs * (1 << i), maxMs);
-      // Synchronous sleep — the public API is sync (matches renameSync), so
-      // setTimeout would change the contract. Spin-wait is acceptable here
-      // because the delays are bounded (≤200ms) and the failure mode is rare.
-      const until = Date.now() + delay;
-      while (Date.now() < until) { /* spin */ }
+      // Synchronous sleep via Atomics.wait — yields the thread instead of
+      // spinning. The public API stays sync (matches renameSync). The
+      // delays remain bounded (≤200ms) and the failure mode is rare.
+      sleepSync(delay);
     }
   }
 }

package/lib/safe-yaml-load.js

@@ -0,0 +1,169 @@
+/**
+ * safe-yaml-load — single-source structured loader for the silent-loader family
+ * (F-721047-010 / D2 amend wave 1).
+ *
+ * **Why this helper exists.** Multiple sites in `packages/findings/**` were
+ * implementing the same pattern: walk a directory, parse `.yaml` (or `.json`)
+ * files, and silently swallow every error with `try { ... } catch {}`. A torn
+ * YAML file, an EACCES, a transient ENOENT — all disappeared, producing
+ * partial results that looked complete. The advisor verified four such sites
+ * (`review/event-log.js walkYaml`, `synthesis/recommendation-derivation.js
+ * loadAcceptedPatterns`, `synthesis/write-artifacts.js loadArtifacts`,
+ * `derive/load-records.js walkRecords/findRecordFile`) and surfaced two
+ * advisor-found siblings in `derive/load-records.js`. The audit's framing
+ * was that this was a "closed" anti-pattern but the header in
+ * `lib/atomic-write.js` actually says it's OPEN — so this fix closes a
+ * known-open pattern rather than regressing on a closure claim.
+ *
+ * **The contract.**
+ *   loadYamlFile(path) → { data, error }
+ *   loadJsonFile(path) → { data, error }
+ *   loadYamlDir(dir, { recursive }) → { entries: [{path, data}], skipped: [{path, error}] }
+ *   loadJsonDir(dir, { recursive }) → same shape
+ *
+ * - On success: `data` is the parsed payload, `error` is `null`.
+ * - On failure: `data` is `null`, `error` is a string ("YAML parse error: …",
+ *   "JSON parse error: …", "Read error: …" etc.). The caller can log the
+ *   structured skip, fail loud, or continue — but never silently disappear.
+ * - This is the same shape `validate.js parseFinding` returns, deliberately
+ *   so existing consumers can swap in this helper without reshaping.
+ *
+ * **What this is NOT.** This is not a schema validator. It only does the
+ * read+parse step. Schema validation lives in `validate.js` for findings
+ * and in `@dogfood-lab/schemas` for the other contracts.
+ *
+ * **Concurrency.** No locking — this is a pure read helper. Callers that
+ * need atomicity layer `withFileLock` on top (see `review/event-log.js
+ * appendEvent`).
+ */
+
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, extname } from 'node:path';
+import yaml from 'js-yaml';
+
+/**
+ * Parse a YAML file. Returns `{ data, error }` — never throws for parse or
+ * read failures.
+ *
+ * @param {string} filePath - Absolute path to a YAML file.
+ * @returns {{ data: unknown, error: string | null }}
+ */
+export function loadYamlFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    return { data: null, error: `Read error: ${err.message}` };
+  }
+  try {
+    const data = yaml.load(raw);
+    return { data, error: null };
+  } catch (err) {
+    return { data: null, error: `YAML parse error: ${err.message}` };
+  }
+}
+
+/**
+ * Parse a JSON file. Returns `{ data, error }` — never throws for parse or
+ * read failures.
+ *
+ * @param {string} filePath - Absolute path to a JSON file.
+ * @returns {{ data: unknown, error: string | null }}
+ */
+export function loadJsonFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    return { data: null, error: `Read error: ${err.message}` };
+  }
+  try {
+    const data = JSON.parse(raw);
+    return { data, error: null };
+  } catch (err) {
+    return { data: null, error: `JSON parse error: ${err.message}` };
+  }
+}
+
+/**
+ * Walk a directory tree and load every matching file using `loadFile`.
+ *
+ * Returns `{ entries, skipped }`:
+ *   - `entries`: `[{ path, data }]` — successful loads.
+ *   - `skipped`: `[{ path, error }]` — files that couldn't be read or parsed,
+ *     each with a structured error string. The caller decides whether to
+ *     log, throw, or just count.
+ *
+ * If `dir` does not exist, returns `{ entries: [], skipped: [] }` (an empty
+ * directory is not an error).
+ *
+ * If `readdirSync` or `statSync` on a child throws, the child is recorded in
+ * `skipped` rather than aborting the whole walk. A torn permission on one
+ * subdir cannot make sibling subdirs disappear.
+ *
+ * @param {string} dir - Absolute path to the directory.
+ * @param {{ recursive?: boolean, ext?: string, loadFile?: (path: string) => { data: unknown, error: string | null } }} [opts]
+ * @returns {{ entries: Array<{ path: string, data: unknown }>, skipped: Array<{ path: string, error: string }> }}
+ */
+function walkDir(dir, { recursive = true, ext = '.yaml', loadFile = loadYamlFile } = {}) {
+  const entries = [];
+  const skipped = [];
+
+  if (!existsSync(dir)) return { entries, skipped };
+
+  function visit(d) {
+    let children;
+    try {
+      children = readdirSync(d);
+    } catch (err) {
+      skipped.push({ path: d, error: `readdir error: ${err.message}` });
+      return;
+    }
+    for (const child of children) {
+      const full = join(d, child);
+      let stat;
+      try {
+        stat = statSync(full);
+      } catch (err) {
+        skipped.push({ path: full, error: `stat error: ${err.message}` });
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (recursive) visit(full);
+        continue;
+      }
+      if (extname(child) !== ext) continue;
+      const { data, error } = loadFile(full);
+      if (error !== null) {
+        skipped.push({ path: full, error });
+      } else {
+        entries.push({ path: full, data });
+      }
+    }
+  }
+
+  visit(dir);
+  return { entries, skipped };
+}
+
+/**
+ * Walk a directory tree and load every `.yaml` file. See `walkDir` for shape.
+ *
+ * @param {string} dir
+ * @param {{ recursive?: boolean }} [opts]
+ * @returns {{ entries: Array<{ path: string, data: unknown }>, skipped: Array<{ path: string, error: string }> }}
+ */
+export function loadYamlDir(dir, opts = {}) {
+  return walkDir(dir, { ...opts, ext: '.yaml', loadFile: loadYamlFile });
+}
+
+/**
+ * Walk a directory tree and load every `.json` file. See `walkDir` for shape.
+ *
+ * @param {string} dir
+ * @param {{ recursive?: boolean }} [opts]
+ * @returns {{ entries: Array<{ path: string, data: unknown }>, skipped: Array<{ path: string, error: string }> }}
+ */
+export function loadJsonDir(dir, opts = {}) {
+  return walkDir(dir, { ...opts, ext: '.json', loadFile: loadJsonFile });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dogfood-lab/findings",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "type": "module",
   "description": "Finding contract spine for testing-os. Validates, reads, lists, and queries evidence-bound findings — the fourth contract alongside record, scenario, and policy.",
   "main": "index.js",
@@ -18,7 +18,7 @@
     "findings": "./cli.js"
   },
   "scripts": {
-    "test": "node --test findings.test.js derive/derive.test.js review/review.test.js synthesis/synthesis.test.js advise/advise.test.js lib/atomic-write.test.js"
+    "test": "node --test findings.test.js derive/derive.test.js derive/load-records-skip.test.js derive/d2b-008-collision-guard.test.js derive/d2b-002-write-schema-gate.test.js review/review.test.js review/event-log-loader.test.js review/h4-engine-auto-reject-reason.test.js synthesis/synthesis.test.js synthesis/loaders-skip.test.js synthesis/d2b-001-derive-skipped-signal.test.js advise/advise.test.js lib/atomic-write.test.js lib/safe-yaml-load.test.js lib/d1b-002-findings-sleepsync.test.js"
   },
   "files": [
     "index.js",
@@ -41,12 +41,10 @@
   "dependencies": {
     "@dogfood-lab/ingest": "^1.2.0",
     "@dogfood-lab/schemas": "^1.2.0",
-    "ajv": "^8.18.0",
-    "ajv-formats": "^3.0.1",
     "js-yaml": "^4.1.0"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "author": "mcp-tool-shop",
   "license": "MIT",

package/reader.js

@@ -1,156 +1,156 @@
-/**
- * Finding reader/lister.
- * Discovers findings from the filesystem, supports filtering and lookup.
- */
-
-import { readdirSync, existsSync, statSync } from 'node:fs';
-import { resolve, join, basename, extname } from 'node:path';
-import { parseFinding, validateFinding } from './validate.js';
-
-/**
- * Discover all .yaml finding files under a root directory.
- * Walks findings/<org>/<repo>/*.yaml
- *
- * @param {string} rootDir - The dogfood-labs repo root.
- * @returns {string[]} Array of absolute paths to finding files.
- */
-export function discoverFindings(rootDir) {
-  const findingsDir = resolve(rootDir, 'findings');
-  if (!existsSync(findingsDir)) return [];
-
-  const paths = [];
-
-  // Walk: findings/<org>/<repo>/*.yaml
-  for (const org of listDirs(findingsDir)) {
-    const orgDir = join(findingsDir, org);
-    for (const repo of listDirs(orgDir)) {
-      const repoDir = join(orgDir, repo);
-      for (const file of readdirSync(repoDir)) {
-        if (extname(file) === '.yaml') {
-          paths.push(resolve(repoDir, file));
-        }
-      }
-    }
-  }
-
-  return paths.sort();
-}
-
-/**
- * Discover finding files from fixtures directory.
- * @param {string} rootDir - The dogfood-labs repo root.
- * @param {'valid' | 'invalid'} kind - Which fixture set.
- * @returns {string[]} Array of absolute paths.
- */
-export function discoverFixtures(rootDir, kind) {
-  const dir = resolve(rootDir, 'fixtures', 'findings', kind);
-  if (!existsSync(dir)) return [];
-
-  return readdirSync(dir)
-    .filter(f => extname(f) === '.yaml')
-    .map(f => resolve(dir, f))
-    .sort();
-}
-
-/**
- * Load all findings from disk (real or fixtures).
- * Returns parsed + validated findings.
- *
- * @param {string} rootDir - The dogfood-labs repo root.
- * @param {{ fixtures?: boolean, fixtureKind?: 'valid' | 'invalid' }} opts
- * @returns {Array<{ path: string, data: object | null, valid: boolean, errors: Array }>}
- */
-export function loadFindings(rootDir, opts = {}) {
-  const paths = opts.fixtures
-    ? discoverFixtures(rootDir, opts.fixtureKind || 'valid')
-    : discoverFindings(rootDir);
-
-  return paths.map(filePath => {
-    const { data, error } = parseFinding(filePath);
-    if (error) {
-      return { path: filePath, data: null, valid: false, errors: [{ path: '/', message: error }] };
-    }
-    const result = validateFinding(data);
-    return { path: filePath, data, ...result };
-  });
-}
-
-/**
- * Find a single finding by its finding_id.
- * Searches real findings first, then fixtures.
- *
- * @param {string} rootDir - The dogfood-labs repo root.
- * @param {string} findingId - The finding_id to look up.
- * @returns {{ path: string, data: object, valid: boolean, errors: Array } | null}
- */
-export function findById(rootDir, findingId) {
-  // Search real findings
-  for (const filePath of discoverFindings(rootDir)) {
-    const { data } = parseFinding(filePath);
-    if (data && data.finding_id === findingId) {
-      const result = validateFinding(data);
-      return { path: filePath, data, ...result };
-    }
-  }
-
-  // Search valid fixtures
-  for (const filePath of discoverFixtures(rootDir, 'valid')) {
-    const { data } = parseFinding(filePath);
-    if (data && data.finding_id === findingId) {
-      const result = validateFinding(data);
-      return { path: filePath, data, ...result };
-    }
-  }
-
-  return null;
-}
-
-/**
- * Filter a list of loaded findings.
- *
- * @param {Array<{ data: object }>} findings - Loaded findings.
- * @param {{ repo?: string, status?: string, surface?: string, issueKind?: string, transferScope?: string }} filters
- * @returns {Array}
- */
-export function filterFindings(findings, filters = {}) {
-  return findings.filter(f => {
-    if (!f.data) return false;
-    if (filters.repo && f.data.repo !== filters.repo) return false;
-    if (filters.status && f.data.status !== filters.status) return false;
-    if (filters.surface && f.data.product_surface !== filters.surface) return false;
-    if (filters.issueKind && f.data.issue_kind !== filters.issueKind) return false;
-    if (filters.transferScope && f.data.transfer_scope !== filters.transferScope) return false;
-    return true;
-  });
-}
-
-/**
- * Check for duplicate finding_ids across all findings.
- * @param {Array<{ data: object, path: string }>} findings
- * @returns {Array<{ findingId: string, paths: string[] }>}
- */
-export function findDuplicates(findings) {
-  const seen = new Map();
-  for (const f of findings) {
-    if (!f.data || !f.data.finding_id) continue;
-    const id = f.data.finding_id;
-    if (!seen.has(id)) seen.set(id, []);
-    seen.get(id).push(f.path);
-  }
-
-  return Array.from(seen.entries())
-    .filter(([, paths]) => paths.length > 1)
-    .map(([findingId, paths]) => ({ findingId, paths }));
-}
-
-/** List subdirectories of a directory. */
-function listDirs(dir) {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir).filter(name => {
-    try {
-      return statSync(join(dir, name)).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-}
+/**
+ * Finding reader/lister.
+ * Discovers findings from the filesystem, supports filtering and lookup.
+ */
+
+import { readdirSync, existsSync, statSync } from 'node:fs';
+import { resolve, join, basename, extname } from 'node:path';
+import { parseFinding, validateFinding } from './validate.js';
+
+/**
+ * Discover all .yaml finding files under a root directory.
+ * Walks findings/<org>/<repo>/*.yaml
+ *
+ * @param {string} rootDir - The dogfood-labs repo root.
+ * @returns {string[]} Array of absolute paths to finding files.
+ */
+export function discoverFindings(rootDir) {
+  const findingsDir = resolve(rootDir, 'findings');
+  if (!existsSync(findingsDir)) return [];
+
+  const paths = [];
+
+  // Walk: findings/<org>/<repo>/*.yaml
+  for (const org of listDirs(findingsDir)) {
+    const orgDir = join(findingsDir, org);
+    for (const repo of listDirs(orgDir)) {
+      const repoDir = join(orgDir, repo);
+      for (const file of readdirSync(repoDir)) {
+        if (extname(file) === '.yaml') {
+          paths.push(resolve(repoDir, file));
+        }
+      }
+    }
+  }
+
+  return paths.sort();
+}
+
+/**
+ * Discover finding files from fixtures directory.
+ * @param {string} rootDir - The dogfood-labs repo root.
+ * @param {'valid' | 'invalid'} kind - Which fixture set.
+ * @returns {string[]} Array of absolute paths.
+ */
+export function discoverFixtures(rootDir, kind) {
+  const dir = resolve(rootDir, 'fixtures', 'findings', kind);
+  if (!existsSync(dir)) return [];
+
+  return readdirSync(dir)
+    .filter(f => extname(f) === '.yaml')
+    .map(f => resolve(dir, f))
+    .sort();
+}
+
+/**
+ * Load all findings from disk (real or fixtures).
+ * Returns parsed + validated findings.
+ *
+ * @param {string} rootDir - The dogfood-labs repo root.
+ * @param {{ fixtures?: boolean, fixtureKind?: 'valid' | 'invalid' }} opts
+ * @returns {Array<{ path: string, data: object | null, valid: boolean, errors: Array }>}
+ */
+export function loadFindings(rootDir, opts = {}) {
+  const paths = opts.fixtures
+    ? discoverFixtures(rootDir, opts.fixtureKind || 'valid')
+    : discoverFindings(rootDir);
+
+  return paths.map(filePath => {
+    const { data, error } = parseFinding(filePath);
+    if (error) {
+      return { path: filePath, data: null, valid: false, errors: [{ path: '/', message: error }] };
+    }
+    const result = validateFinding(data);
+    return { path: filePath, data, ...result };
+  });
+}
+
+/**
+ * Find a single finding by its finding_id.
+ * Searches real findings first, then fixtures.
+ *
+ * @param {string} rootDir - The dogfood-labs repo root.
+ * @param {string} findingId - The finding_id to look up.
+ * @returns {{ path: string, data: object, valid: boolean, errors: Array } | null}
+ */
+export function findById(rootDir, findingId) {
+  // Search real findings
+  for (const filePath of discoverFindings(rootDir)) {
+    const { data } = parseFinding(filePath);
+    if (data && data.finding_id === findingId) {
+      const result = validateFinding(data);
+      return { path: filePath, data, ...result };
+    }
+  }
+
+  // Search valid fixtures
+  for (const filePath of discoverFixtures(rootDir, 'valid')) {
+    const { data } = parseFinding(filePath);
+    if (data && data.finding_id === findingId) {
+      const result = validateFinding(data);
+      return { path: filePath, data, ...result };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Filter a list of loaded findings.
+ *
+ * @param {Array<{ data: object }>} findings - Loaded findings.
+ * @param {{ repo?: string, status?: string, surface?: string, issueKind?: string, transferScope?: string }} filters
+ * @returns {Array}
+ */
+export function filterFindings(findings, filters = {}) {
+  return findings.filter(f => {
+    if (!f.data) return false;
+    if (filters.repo && f.data.repo !== filters.repo) return false;
+    if (filters.status && f.data.status !== filters.status) return false;
+    if (filters.surface && f.data.product_surface !== filters.surface) return false;
+    if (filters.issueKind && f.data.issue_kind !== filters.issueKind) return false;
+    if (filters.transferScope && f.data.transfer_scope !== filters.transferScope) return false;
+    return true;
+  });
+}
+
+/**
+ * Check for duplicate finding_ids across all findings.
+ * @param {Array<{ data: object, path: string }>} findings
+ * @returns {Array<{ findingId: string, paths: string[] }>}
+ */
+export function findDuplicates(findings) {
+  const seen = new Map();
+  for (const f of findings) {
+    if (!f.data || !f.data.finding_id) continue;
+    const id = f.data.finding_id;
+    if (!seen.has(id)) seen.set(id, []);
+    seen.get(id).push(f.path);
+  }
+
+  return Array.from(seen.entries())
+    .filter(([, paths]) => paths.length > 1)
+    .map(([findingId, paths]) => ({ findingId, paths }));
+}
+
+/** List subdirectories of a directory. */
+function listDirs(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter(name => {
+    try {
+      return statSync(join(dir, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}

package/review/event-log.js

@@ -4,13 +4,14 @@
  * Events are stored as YAML arrays in reviews/<YYYY>/<date>-finding-review-log.yaml
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from 'node:fs';
-import { resolve, dirname, join } from 'node:path';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import yaml from 'js-yaml';
 
 import { withFileLock } from '../lib/file-lock.js';
 import { renameWithRetry } from '../lib/rename-with-retry.js';
+import { loadYamlDir } from '../lib/safe-yaml-load.js';
 
 let _eventCounter = 0;
 
@@ -147,31 +148,56 @@ export function getEventsForFinding(rootDir, findingId) {
 
 /**
  * Read all events across all findings.
+ *
+ * Legacy shape: returns an array of events. Torn log files are NOT silently
+ * dropped — they surface as structured skip records via the sibling API
+ * `getAllEventsWithSkips()`. Callers that need to see which log files
+ * failed to load should use that API; this one is kept array-shaped for
+ * backward compatibility with the existing read sites (CLI display,
+ * `getEventsForFinding`, the review.test.js / event-log-race.test.js
+ * fixtures).
+ *
+ * H1 / F-721047-010 — silent-loader closure: previously the internal
+ * `walkYaml` helper wrapped the whole `readdir`/`statSync`/`readFileSync`/
+ * `yaml.load` loop in a single `try { ... } catch { /* skip bad files * / }`,
+ * which made torn YAML, EACCES, and ENOENT all disappear with no signal.
+ * The walk is now delegated to `loadYamlDir`, which returns
+ * `{ entries, skipped }` — every torn file is recorded with a structured
+ * error rather than dropped.
  */
 export function getAllEvents(rootDir) {
-  const reviewsDir = resolve(rootDir, 'reviews');
-  if (!existsSync(reviewsDir)) return [];
+  return getAllEventsWithSkips(rootDir).events;
+}
 
-  const events = [];
-  walkYaml(reviewsDir, data => {
-    if (Array.isArray(data)) events.push(...data);
-  });
+/**
+ * Read all events across all findings, plus a list of any log files that
+ * failed to load (torn YAML, EACCES, etc.). The structured-skip API the
+ * audit asked for — callers that care about pipeline honesty (rebuild
+ * scripts, doctor commands, CI checks) should consume this one rather
+ * than the array-shaped legacy `getAllEvents`.
+ *
+ * @param {string} rootDir
+ * @returns {{ events: object[], skipped: Array<{ path: string, error: string }> }}
+ */
+export function getAllEventsWithSkips(rootDir) {
+  const reviewsDir = resolve(rootDir, 'reviews');
+  if (!existsSync(reviewsDir)) return { events: [], skipped: [] };
 
-  return events.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
-}
+  const { entries, skipped } = loadYamlDir(reviewsDir, { recursive: true });
 
-/** Walk directory tree for .yaml files, parse and call cb with data. */
-function walkYaml(dir, cb) {
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    try {
-      if (statSync(full).isDirectory()) {
-        walkYaml(full, cb);
-      } else if (entry.endsWith('.yaml')) {
-        const raw = readFileSync(full, 'utf-8');
-        const data = yaml.load(raw);
-        if (data) cb(data);
-      }
-    } catch { /* skip bad files */ }
+  const events = [];
+  for (const entry of entries) {
+    const data = entry.data;
+    if (!data) continue;
+    if (Array.isArray(data)) {
+      events.push(...data);
+    } else {
+      // A single-event YAML file (defensive: shouldn't happen for daily logs,
+      // but the original walkYaml tolerated either shape).
+      events.push(data);
+    }
   }
+
+  events.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
+  return { events, skipped };
 }