@hegemonart/get-design-done 1.19.0 → 1.19.5

package/agents/design-verifier-gate.md

@@ -94,4 +94,14 @@ You MAY:
 
 Per 10.1-CONTEXT decision **D-21** (Lazy Checker Spawning): "Cheap Haiku gate agents at `agents/*-gate.md` decide whether to spawn full checker. Gate agent: reads DIFF of changed files, applies heuristic (design-system paths touched? copy strings touched? token files touched?), returns `{spawn: true|false, rationale: '...'}`. If false, skip full checker, log as `lazy_skipped: true` in telemetry." This gate is the verifier-specific instance of that pattern — full `design-verifier` is an XL-size spawn and the most expensive single agent in the pipeline, so gating it behind a cheap Haiku diff-scan yields the largest single cost win in Phase 10.1.
 
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
+
 ## GATE COMPLETE

package/agents/design-verifier.md

@@ -553,6 +553,17 @@ Emit a 2–4 sentence summary paragraph describing results, then:
 Emit `## GAPS FOUND` heading, then the full structured gap list (BLOCKER first, MAJOR, MINOR, COSMETIC), then on a new line:
 
 ```
+
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
+
 ## VERIFICATION COMPLETE
 ```
 

package/agents/gdd-graphify-sync.md

@@ -98,3 +98,13 @@ Graphify status: <status line>
 @.design/intel/files.json (if present)
 
 ## GRAPHIFY-SYNC COMPLETE
+
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.

package/agents/gdd-intel-updater.md

@@ -85,4 +85,14 @@ Generated:      <timestamp>
 A slice is stale if its `generated` timestamp is older than the newest `mtime` in `files.json`.
 The updater does not need to check this manually — `build-intel.cjs` handles mtime comparison.
 
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
+
 ## INTEL UPDATE COMPLETE

package/agents/gdd-learnings-extractor.md

@@ -82,4 +82,14 @@ For each learning with `Proposed reference update: yes`:
 @.design/intel/patterns.json (if present)
 @.design/learnings/LEARNINGS.md (if present)
 
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
+
 ## LEARNINGS EXTRACTION COMPLETE

package/agents/motion-mapper.md

@@ -210,4 +210,14 @@ If no violations found, emit: `## Micro-motion findings — CLEAN (0 violations)
 
 No modifications outside `.design/map/`. No git. No agent spawning.
 
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
+
 ## MOTION MAP COMPLETE

package/agents/token-mapper.md

@@ -144,4 +144,14 @@ Total: N findings. (0 = clean)
 
 You MUST NOT modify anything outside `.design/map/`. Do not run git commands or spawn agents.
 
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
+
 ## TOKEN MAP COMPLETE

package/agents/visual-hierarchy-mapper.md

@@ -121,4 +121,14 @@ Total: N findings.
 
 No modifications outside `.design/map/`. No git. No agent spawning.
 
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"<name>","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<what was produced or learned>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
+
 ## VISUAL HIERARCHY MAP COMPLETE

package/hooks/gdd-decision-injector.js

@@ -25,6 +25,14 @@ const MIN_BYTES = 1500;
 const TOP_N = 15;
 const MATCHER_RE = /[\\/](?:\.design|reference|\.planning)[\\/][^\n]*\.md$/;
 
+// Phase 19.5: try FTS5 backend first; fall back to grep silently.
+let _designSearch = null;
+try {
+  _designSearch = require(path.join(__dirname, '..', 'scripts', 'lib', 'design-search.cjs'));
+} catch { /* not available in this install */ }
+
+const BACKEND = _designSearch ? _designSearch.backendName() : null;
+
 function ripgrepAvailable() {
   try {
     const r = spawnSync('rg', ['--version'], { encoding: 'utf8', windowsHide: true });
@@ -103,7 +111,7 @@ function sortKeyFor(tag) {
   return 0;
 }
 
-function buildRecallBlock(matches, basename) {
+function buildRecallBlock(matches, basename, backendLabel) {
   if (!matches.length) return null;
   const uniq = [];
   const seen = new Set();
@@ -125,10 +133,11 @@ function buildRecallBlock(matches, basename) {
     const excerpt = m.text.length > 140 ? m.text.slice(0, 137) + '…' : m.text;
     lines.push(`> - [${tag}] ${excerpt} (${path.relative(process.cwd(), m.file)}:${m.line})`);
   }
+  // backendLabel passed in from main()
   if (uniq.length > TOP_N) {
-    lines.push(`> … (${uniq.length - TOP_N} more matches; use \`/gdd:recall <term>\` to expand. Grep backend; FTS5 upgrade in Phase 19.5.)`);
+    lines.push(`> … (${uniq.length - TOP_N} more matches; use \`/gdd:recall <term>\` to expand. Backend: ${backendLabel}.)`);
   } else {
-    lines.push(`> (${uniq.length} match${uniq.length === 1 ? '' : 'es'} surfaced. Grep backend; FTS5 upgrade in Phase 19.5.)`);
+    lines.push(`> (${uniq.length} match${uniq.length === 1 ? '' : 'es'} surfaced. Backend: ${backendLabel}.)`);
   }
   lines.push('');
   return lines.join('\n');
@@ -173,13 +182,26 @@ async function main() {
     return;
   }
 
-  const useRg = ripgrepAvailable();
-  const hits = [];
-  for (const src of sources) {
-    hits.push(...(useRg ? grepLinesRg(src, terms) : grepLinesNode(src, terms)));
+  const useRgGlobal = ripgrepAvailable();
+  let hits = [];
+  if (BACKEND === 'fts5' && _designSearch) {
+    // FTS5 path: single query across all indexed docs
+    try {
+      const query = terms.join(' OR ');
+      hits = _designSearch.search(query, cwd, { limit: TOP_N * 3 });
+    } catch { hits = []; }
+    if (!hits.length) {
+      // FTS5 db may be stale — rebuild silently then retry
+      try { _designSearch.reindex(cwd); hits = _designSearch.search(terms.join(' OR '), cwd, { limit: TOP_N * 3 }); } catch { hits = []; }
+    }
+  } else {
+    for (const src of sources) {
+      hits.push(...(useRgGlobal ? grepLinesRg(src, terms) : grepLinesNode(src, terms)));
+    }
   }
 
-  const block = buildRecallBlock(hits, basename);
+  const backendLabel = BACKEND || (useRgGlobal ? 'ripgrep' : 'node-grep');
+  const block = buildRecallBlock(hits, basename, backendLabel);
   if (!block) {
     process.stdout.write(JSON.stringify({ continue: true }));
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hegemonart/get-design-done",
-  "version": "1.19.0",
+  "version": "1.19.5",
   "description": "A Claude Code plugin for systematic design improvement",
   "author": "Hegemon",
   "homepage": "https://github.com/hegemonart/get-design-done",
@@ -82,7 +82,14 @@
     "information-architecture",
     "form-patterns",
     "data-viz",
-    "platforms"
+    "platforms",
+    "cross-cycle-memory",
+    "fts5",
+    "checkpoints",
+    "experience-archive",
+    "recall",
+    "relevance-counter",
+    "record-contract"
   ],
   "skills": [
     "SKILL.md"

package/reference/registry.json

@@ -380,6 +380,13 @@
       "type": "heuristic",
       "description": "Nav pattern catalog, menu-depth rules, card sort/tree test benchmarks, wayfinding, faceted nav"
     },
+    {
+      "name": "insight-line.schema",
+      "path": "reference/schemas/insight-line.schema.json",
+      "type": "schema",
+      "tier": "haiku",
+      "description": "JSONL schema for agent run-end insight lines written to .design/intel/insights.jsonl"
+    },
     {
       "name": "intel-schema",
       "path": "reference/intel-schema.md",

package/reference/schemas/insight-line.schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "AgentInsightLine",
+  "description": "One JSONL line appended by an agent to .design/intel/insights.jsonl at run-end.",
+  "type": "object",
+  "required": ["ts", "agent", "cycle", "stage", "one_line_insight", "artifacts_written"],
+  "additionalProperties": false,
+  "properties": {
+    "ts": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of the agent run completion."
+    },
+    "agent": {
+      "type": "string",
+      "description": "Agent name matching the frontmatter 'name' field (e.g. 'design-planner')."
+    },
+    "cycle": {
+      "type": "string",
+      "description": "Active cycle ID from STATE.md (e.g. 'cycle-1'). Empty string if not in a cycle."
+    },
+    "stage": {
+      "type": "string",
+      "description": "Pipeline stage from STATE.md (e.g. 'plan', 'design', 'verify')."
+    },
+    "one_line_insight": {
+      "type": "string",
+      "maxLength": 200,
+      "description": "One declarative sentence: what this agent produced or learned this run."
+    },
+    "artifacts_written": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Relative paths of files written during this run. Empty array for read-only agents."
+    }
+  }
+}

package/scripts/lib/design-search.cjs

@@ -0,0 +1,206 @@
+'use strict';
+/**
+ * design-search.cjs — cross-cycle recall search backend.
+ *
+ * Priority chain:
+ *   1. FTS5 via better-sqlite3 (fast, ranked)  — when module is available
+ *   2. ripgrep                                  — when rg is on PATH
+ *   3. Node fs line scan                        — universal fallback
+ *
+ * Public API:
+ *   search(query, projectRoot, opts?) → [{file, line, text}]
+ *   reindex(projectRoot)              → void  (rebuilds FTS5 DB; no-op on grep path)
+ *   backendName()                     → 'fts5' | 'ripgrep' | 'node-grep'
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { probeOptional } = require('./probe-optional.cjs');
+
+// ---------------------------------------------------------------------------
+// Backend selection (evaluated once at module load)
+// ---------------------------------------------------------------------------
+
+const Database = probeOptional('better-sqlite3');
+
+let _fts5Supported = false;
+if (Database) {
+  try {
+    const probe = new Database(':memory:');
+    probe.exec('CREATE VIRTUAL TABLE _p USING fts5(t)');
+    probe.close();
+    _fts5Supported = true;
+  } catch { /* fts5 extension not compiled in */ }
+}
+
+function _rgAvailable() {
+  try {
+    const r = spawnSync('rg', ['--version'], { encoding: 'utf8', windowsHide: true });
+    return r.status === 0;
+  } catch { return false; }
+}
+
+const _hasRg = _rgAvailable();
+
+function backendName() {
+  if (_fts5Supported) return 'fts5';
+  if (_hasRg) return 'ripgrep';
+  return 'node-grep';
+}
+
+// ---------------------------------------------------------------------------
+// Index paths
+// ---------------------------------------------------------------------------
+
+const INDEXED_GLOBS = [
+  '.design/archive/**/*.md',
+  '.design/learnings/LEARNINGS.md',
+  '.design/CYCLES.md',
+];
+
+function _dbPath(projectRoot) {
+  return path.join(projectRoot, '.design', 'search.db');
+}
+
+function _collectFiles(projectRoot) {
+  const results = [];
+  function walk(dir) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) { walk(full); continue; }
+      if (e.name.endsWith('.md')) results.push(full);
+    }
+  }
+  walk(path.join(projectRoot, '.design', 'archive'));
+  for (const rel of [
+    path.join('.design', 'learnings', 'LEARNINGS.md'),
+    path.join('.design', 'CYCLES.md'),
+  ]) {
+    const full = path.join(projectRoot, rel);
+    if (fs.existsSync(full)) results.push(full);
+  }
+  // STATE.md decision blocks
+  const state = path.join(projectRoot, '.design', 'STATE.md');
+  if (fs.existsSync(state)) results.push(state);
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// FTS5 backend
+// ---------------------------------------------------------------------------
+
+function _openDb(projectRoot) {
+  const dbPath = _dbPath(projectRoot);
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS docs USING fts5(
+      file UNINDEXED, line UNINDEXED, text, tokenize='trigram'
+    );
+  `);
+  return db;
+}
+
+function reindex(projectRoot) {
+  if (!_fts5Supported) return;
+  const db = _openDb(projectRoot);
+  db.exec('DELETE FROM docs');
+  const insert = db.prepare('INSERT INTO docs(file, line, text) VALUES (?,?,?)');
+  const txn = db.transaction((files) => {
+    for (const file of files) {
+      let content;
+      try { content = fs.readFileSync(file, 'utf8'); } catch { continue; }
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        const t = lines[i].trim();
+        if (t) insert.run(file, i + 1, t);
+      }
+    }
+  });
+  txn(_collectFiles(projectRoot));
+  db.close();
+}
+
+function _searchFts5(query, projectRoot, limit) {
+  const dbPath = _dbPath(projectRoot);
+  if (!fs.existsSync(dbPath)) reindex(projectRoot);
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const rows = db.prepare(
+      `SELECT file, line, text FROM docs WHERE docs MATCH ? ORDER BY rank LIMIT ?`
+    ).all(query, limit);
+    return rows.map(r => ({ file: r.file, line: r.line, text: r.text }));
+  } finally {
+    db.close();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Ripgrep backend
+// ---------------------------------------------------------------------------
+
+function _escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function _searchRg(query, projectRoot, limit) {
+  const terms = query.split(/\s+/).filter(Boolean);
+  const pattern = terms.map(_escapeRe).join('|');
+  const targets = _collectFiles(projectRoot);
+  if (!targets.length || !pattern) return [];
+  const r = spawnSync('rg', ['-n', '--no-heading', '-i', '-S', pattern, ...targets], {
+    encoding: 'utf8', windowsHide: true,
+  });
+  const results = [];
+  for (const line of (r.stdout || '').split(/\r?\n/)) {
+    const m = line.match(/^(.+?):(\d+):(.*)$/);
+    if (m) results.push({ file: m[1], line: Number(m[2]), text: m[3].trim() });
+    if (results.length >= limit) break;
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Node fs fallback backend
+// ---------------------------------------------------------------------------
+
+function _searchNode(query, projectRoot, limit) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const files = _collectFiles(projectRoot);
+  const results = [];
+  for (const file of files) {
+    let content;
+    try { content = fs.readFileSync(file, 'utf8'); } catch { continue; }
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const lower = lines[i].toLowerCase();
+      if (terms.every(t => lower.includes(t))) {
+        results.push({ file, line: i + 1, text: lines[i].trim() });
+        if (results.length >= limit) return results;
+      }
+    }
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Public search
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {string} query
+ * @param {string} projectRoot  absolute path to the project (contains .design/)
+ * @param {{ limit?: number }} [opts]
+ * @returns {{ file: string, line: number, text: string }[]}
+ */
+function search(query, projectRoot, opts = {}) {
+  const limit = opts.limit ?? 20;
+  if (_fts5Supported) return _searchFts5(query, projectRoot, limit);
+  if (_hasRg) return _searchRg(query, projectRoot, limit);
+  return _searchNode(query, projectRoot, limit);
+}
+
+module.exports = { search, reindex, backendName };

package/scripts/lib/probe-optional.cjs

@@ -0,0 +1,29 @@
+'use strict';
+/**
+ * probe-optional.cjs — safely require optional native dependencies.
+ *
+ * Usage:
+ *   const { probeOptional } = require('./probe-optional.cjs');
+ *   const Database = probeOptional('better-sqlite3');
+ *   if (Database) { ... } else { // fallback }
+ *
+ * Returns the module if available and natively compatible, null otherwise.
+ * Swallows MODULE_NOT_FOUND and native binding errors silently — callers
+ * must implement their own fallback path.
+ */
+function probeOptional(name) {
+  try {
+    return require(name);
+  } catch (e) {
+    if (
+      e.code === 'MODULE_NOT_FOUND' ||
+      e.message?.includes('was compiled against a different Node.js version') ||
+      e.message?.includes('NODE_MODULE_VERSION')
+    ) {
+      return null;
+    }
+    throw e;
+  }
+}
+
+module.exports = { probeOptional };

package/scripts/lib/relevance-counter.cjs

@@ -0,0 +1,121 @@
+'use strict';
+/**
+ * relevance-counter.cjs — tracks per-learning signal counts.
+ *
+ * Signals: 'cited' | 'surfaced' | 'dismissed'
+ *
+ * Writes to `.design/learnings/.relevance.json` under an atomic-write
+ * pattern (write tmp → rename) guarded by a `.relevance.lock` file so
+ * concurrent agents don't clobber each other.
+ *
+ * Public API:
+ *   record(id, signal, designDir)  → void
+ *   load(designDir)                → { [id]: { cited, surfaced, dismissed, last_used } }
+ *   shouldPromote(id, designDir)   → boolean  (cited >= 8)
+ *   shouldPrune(id, age, designDir) → boolean (cited === 0 and age >= 4 cycles)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SIGNALS = new Set(['cited', 'surfaced', 'dismissed']);
+const PROMOTE_THRESHOLD = 8;
+
+function _counterPath(designDir) {
+  return path.join(designDir, 'learnings', '.relevance.json');
+}
+
+function _lockPath(designDir) {
+  return path.join(designDir, 'learnings', '.relevance.lock');
+}
+
+function _acquireLock(lockPath, timeout = 5000) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    try {
+      fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+      return true;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      // Check for stale lock (> 30s old)
+      try {
+        const stat = fs.statSync(lockPath);
+        if (Date.now() - stat.mtimeMs > 30000) {
+          fs.unlinkSync(lockPath);
+          continue;
+        }
+      } catch { /* lock was removed between our check and unlink */ }
+      // Brief spin
+      const end = Date.now() + 50;
+      while (Date.now() < end) { /* spin */ }
+    }
+  }
+  return false;
+}
+
+function _releaseLock(lockPath) {
+  try { fs.unlinkSync(lockPath); } catch { /* already gone */ }
+}
+
+function load(designDir) {
+  const p = _counterPath(designDir);
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Record a signal for a learning entry id.
+ * @param {string} id      Learning ID (e.g. "L-01")
+ * @param {'cited'|'surfaced'|'dismissed'} signal
+ * @param {string} designDir  Path to the .design/ directory
+ */
+function record(id, signal, designDir) {
+  if (!SIGNALS.has(signal)) throw new Error(`Unknown signal: ${signal}`);
+  fs.mkdirSync(path.join(designDir, 'learnings'), { recursive: true });
+
+  const lockPath = _lockPath(designDir);
+  if (!_acquireLock(lockPath)) {
+    // Non-fatal — skip the update rather than corrupting the store
+    return;
+  }
+
+  try {
+    const data = load(designDir);
+    if (!data[id]) {
+      data[id] = { cited: 0, surfaced: 0, dismissed: 0, last_used: null };
+    }
+    data[id][signal]++;
+    data[id].last_used = new Date().toISOString();
+
+    // Atomic write: tmp → rename
+    const counterPath = _counterPath(designDir);
+    const tmp = counterPath + '.tmp.' + process.pid;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    fs.renameSync(tmp, counterPath);
+  } finally {
+    _releaseLock(lockPath);
+  }
+}
+
+function shouldPromote(id, designDir) {
+  const data = load(designDir);
+  return (data[id]?.cited ?? 0) >= PROMOTE_THRESHOLD;
+}
+
+/**
+ * @param {string} id
+ * @param {number} ageCycles  number of cycles since last_used (or since created)
+ * @param {string} designDir
+ */
+function shouldPrune(id, ageCycles, designDir) {
+  const data = load(designDir);
+  const entry = data[id];
+  if (!entry) return false;
+  return entry.cited === 0 && ageCycles >= 4;
+}
+
+module.exports = { record, load, shouldPromote, shouldPrune };