@mindrian_os/install 1.13.0-beta.12 → 1.13.0-beta.14

package/lib/core/feynman/timeline-runner.cjs

@@ -0,0 +1,281 @@
+'use strict';
+// Phase 124-02 -- FEYNMAN.md timeline runner
+// =========================================
+// The side-effect orchestrator. Walks a room's section folders, finds each FEYNMAN.md,
+// applies the D-02 sentinel-bounded merge over the body returned by the pure renderer
+// (Plan 124-01), writes back atomically (.tmp + rename), updates the timeline_last_rendered
+// frontmatter, and logs a memory_event on every refresh attempt (success or failure).
+//
+// Honors the D-09 watermark contract: skip when the frontmatter timeline_last_rendered ISO
+// is >= the SQL MAX(memory_event.created_at) ISO for the section (second-resolution).
+//
+// The renderer (timeline-renderer.cjs) is the pure function. The runner is the impure shell
+// around it. tests/test-feynman-timeline-runner.cjs is the integration test for this module.
+//
+// Canon Part 9: every refresh logs a typed memory_event making the regenerate-vs-skip
+// decision legible in the local mind. Canon Part 8: zero net new Brain surface.
+// Canon Part 7: reuses the atomic .tmp + rename idiom from scripts/vault-section-minto-generator.cjs;
+//               the frontmatter line-walk parser idiom from scripts/frontmatter-schema-validator.cjs.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const renderer = require('./timeline-renderer.cjs');
+const navigation = require('../navigation.cjs');
+
+// ---------- Sentinel contract (D-02) ----------
+
+const SENTINEL_START = '<!-- TIMELINE_AUTO_START -->';
+const SENTINEL_END = '<!-- TIMELINE_AUTO_END -->';
+const HEADER = '## Timeline (auto)';
+
+// ---------- Frontmatter helpers (hand-rolled; no gray-matter) ----------
+
+function parseFrontmatter(content) {
+  // Returns { fm: { [key]: value }, fmOrder: [keys...], body: '<rest>', hadFrontmatter: bool }.
+  const lines = content.split('\n');
+  if (lines.length === 0 || lines[0].trim() !== '---') {
+    return { fm: {}, fmOrder: [], body: content, hadFrontmatter: false };
+  }
+  let endIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') { endIdx = i; break; }
+  }
+  if (endIdx === -1) {
+    return { fm: {}, fmOrder: [], body: content, hadFrontmatter: false };
+  }
+  const fmLines = lines.slice(1, endIdx);
+  const bodyLines = lines.slice(endIdx + 1);
+  const fm = {};
+  const fmOrder = [];
+  for (const ln of fmLines) {
+    const m = ln.match(/^([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/);
+    if (!m) continue;
+    const key = m[1];
+    const raw = m[2];
+    let val;
+    if (raw === '' || raw === 'null') val = null;
+    else if (raw === 'true') val = true;
+    else if (raw === 'false') val = false;
+    else if (/^-?\d+(\.\d+)?$/.test(raw)) val = Number(raw);
+    else if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) val = raw.slice(1, -1);
+    else val = raw;
+    fm[key] = val;
+    if (fmOrder.indexOf(key) === -1) fmOrder.push(key);
+  }
+  return { fm: fm, fmOrder: fmOrder, body: bodyLines.join('\n'), hadFrontmatter: true };
+}
+
+function serializeFrontmatter(fm, fmOrder, body, hadFrontmatter) {
+  // If fm is empty AND there was no original frontmatter -> return body unchanged.
+  const keys = Object.keys(fm);
+  if (keys.length === 0 && !hadFrontmatter) return body;
+  // Honor fmOrder for existing keys; append any new keys not in fmOrder at the end.
+  const order = fmOrder.slice();
+  for (const k of keys) {
+    if (order.indexOf(k) === -1) order.push(k);
+  }
+  const out = ['---'];
+  for (const k of order) {
+    if (!(k in fm)) continue;
+    const v = fm[k];
+    if (v === null) out.push(k + ':');
+    else if (typeof v === 'boolean' || typeof v === 'number') out.push(k + ': ' + String(v));
+    else out.push(k + ': ' + String(v));
+  }
+  out.push('---');
+  return out.join('\n') + '\n' + body;
+}
+
+// ---------- Sentinel-bounded merge (D-02 hard invariant) ----------
+
+function mergeSentinelSection(body, renderedBody) {
+  // Case A: the sentinel pair exists -- replace the content between.
+  const startIdx = body.indexOf(SENTINEL_START);
+  const endIdx = body.indexOf(SENTINEL_END);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = body.slice(0, startIdx + SENTINEL_START.length);
+    const after = body.slice(endIdx);
+    return before + '\n' + renderedBody + '\n' + after;
+  }
+  // Case B: no sentinel pair -- append at end-of-file (ensure trailing newline).
+  const sep = body.endsWith('\n') ? '' : '\n';
+  return body + sep + '\n' + HEADER + '\n\n' + SENTINEL_START + '\n' + renderedBody + '\n' + SENTINEL_END + '\n';
+}
+
+function bodyOutsideSentinels(body) {
+  // For the SHA256 byte-preservation check. Returns the body with the sentinel block excised
+  // (everything from SENTINEL_START to SENTINEL_END inclusive removed, plus the lines they
+  // sit on). If no sentinels, returns the body unchanged.
+  const startIdx = body.indexOf(SENTINEL_START);
+  const endIdx = body.indexOf(SENTINEL_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return body;
+  // Find the start of the line containing SENTINEL_START (back up to the previous newline)
+  // and the end of the line containing SENTINEL_END (forward to the next newline).
+  let lineStart = body.lastIndexOf('\n', startIdx);
+  if (lineStart === -1) lineStart = 0;
+  let lineEnd = body.indexOf('\n', endIdx + SENTINEL_END.length);
+  if (lineEnd === -1) lineEnd = body.length;
+  return body.slice(0, lineStart) + body.slice(lineEnd);
+}
+
+function sha256Hex(s) {
+  return crypto.createHash('sha256').update(s, 'utf8').digest('hex');
+}
+
+// ---------- Atomic write (D-02 hard invariant: no partial-write corruption) ----------
+
+function atomicWrite(targetPath, content) {
+  const dir = path.dirname(targetPath);
+  const base = path.basename(targetPath);
+  const tmp = path.join(dir, '.' + base + '.tmp.' + process.pid + '.' + Date.now());
+  const fd = fs.openSync(tmp, 'w');
+  try {
+    fs.writeSync(fd, content, 0, 'utf8');
+    try { fs.fsyncSync(fd); } catch (_) { /* fsync best-effort on platforms without it */ }
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, targetPath);
+}
+
+// ---------- Section walk ----------
+
+function safeIsDir(p) { try { return fs.statSync(p).isDirectory(); } catch (_) { return false; } }
+function safeIsFile(p) { try { return fs.statSync(p).isFile(); } catch (_) { return false; } }
+
+function findFeynmanSections(roomDir) {
+  // Subdirectories of roomDir that contain a FEYNMAN.md at <roomDir>/<section>/FEYNMAN.md.
+  if (!safeIsDir(roomDir)) return [];
+  let entries;
+  try {
+    entries = fs.readdirSync(roomDir, { withFileTypes: true });
+  } catch (_) {
+    return [];
+  }
+  const out = [];
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    if (ent.name.startsWith('.')) continue;
+    if (ent.name === 'node_modules') continue;
+    const feyPath = path.join(roomDir, ent.name, 'FEYNMAN.md');
+    if (safeIsFile(feyPath)) out.push({ slug: ent.name, feyPath: feyPath });
+  }
+  out.sort((a, b) => a.slug.localeCompare(b.slug));
+  return out;
+}
+
+// ---------- Watermark check (D-09) ----------
+
+function shouldSkipWatermark(db, sectionSlug, fmRendered) {
+  if (typeof fmRendered !== 'string' || fmRendered.length === 0) return false;
+  let summary;
+  try {
+    summary = navigation.firstCapturedLastTouchedBySection(db, sectionSlug);
+  } catch (_) {
+    return false;
+  }
+  if (!summary || summary.total_events === 0) return false; // no events; refresh to empty-state if needed.
+  const sqlIso = renderer.isoSecond(summary.last_touched_ms);
+  if (!sqlIso) return false;
+  // ISO 8601 second-resolution strings are lex-sortable.
+  return sqlIso <= fmRendered;
+}
+
+// ---------- The orchestrator ----------
+
+function refreshSection(roomDir, sectionSlug, opts) {
+  const options = opts || {};
+  const db = options.db;
+  const now_ms = Number.isFinite(options.now_ms) ? options.now_ms : Date.now();
+  const force = options.force === true;
+  const feyPath = path.join(roomDir, sectionSlug, 'FEYNMAN.md');
+
+  if (!safeIsFile(feyPath)) {
+    return { status: 'skipped_no_feynman', reason: 'no_feynman_md_in_section_dir' };
+  }
+
+  try {
+    const rawContent = fs.readFileSync(feyPath, 'utf8');
+    const parsed = parseFrontmatter(rawContent);
+
+    // D-09 watermark check.
+    if (!force && db && typeof parsed.fm.timeline_last_rendered === 'string') {
+      if (shouldSkipWatermark(db, sectionSlug, parsed.fm.timeline_last_rendered)) {
+        return { status: 'skipped_watermark', reason: 'sql_older_than_rendered' };
+      }
+    }
+
+    // Render (D-05). Reads ONLY via navigation.cjs.
+    const rendered = renderer.renderTimeline(db, sectionSlug, { now_ms: now_ms });
+
+    // Merge (D-02 hard invariant).
+    const newBody = mergeSentinelSection(parsed.body, rendered.markdown_body);
+
+    // Update frontmatter watermark (D-09).
+    const newIso = renderer.isoSecond(now_ms);
+    const newFm = Object.assign({}, parsed.fm, { timeline_last_rendered: newIso });
+    // Force frontmatter emission on every refresh (true so the watermark always lands at
+    // the top, even when the original file had no fences).
+    const newContent = serializeFrontmatter(newFm, parsed.fmOrder, newBody, true);
+
+    // Atomic write.
+    atomicWrite(feyPath, newContent);
+
+    // Log success memory_event (D-10).
+    if (db) {
+      try {
+        navigation.logMemoryEvent(db, 'feynman_timeline_refreshed', {
+          source_path: 'feynman:' + sectionSlug,
+          created_by: 'system',
+        });
+      } catch (_) { /* logging failure does not corrupt the refresh; the write already landed */ }
+    }
+
+    return { status: 'refreshed', written_path: feyPath, watermark: newIso };
+  } catch (err) {
+    const reason = (err && err.message) ? String(err.message).slice(0, 200) : 'unknown_error';
+    if (db) {
+      try {
+        navigation.logMemoryEvent(db, 'feynman_timeline_refresh_failed', {
+          source_path: 'feynman:' + sectionSlug,
+          created_by: 'system',
+          reason: reason,
+        });
+      } catch (_) { /* secondary failure is swallowed */ }
+    }
+    return { status: 'failed', reason: reason };
+  }
+}
+
+function refreshAll(roomDir, opts) {
+  const options = opts || {};
+  const refreshed = [];
+  const skipped = [];
+  const failed = [];
+  const sections = findFeynmanSections(roomDir);
+  for (const s of sections) {
+    const r = refreshSection(roomDir, s.slug, options);
+    if (r.status === 'refreshed') refreshed.push({ slug: s.slug, written_path: r.written_path, watermark: r.watermark });
+    else if (r.status === 'failed') failed.push({ slug: s.slug, reason: r.reason });
+    else skipped.push({ slug: s.slug, reason: r.reason || r.status });
+  }
+  return { refreshed: refreshed, skipped: skipped, failed: failed };
+}
+
+module.exports = {
+  refreshAll,
+  refreshSection,
+  parseFrontmatter,
+  serializeFrontmatter,
+  mergeSentinelSection,
+  bodyOutsideSentinels,
+  sha256Hex,
+  findFeynmanSections,
+  shouldSkipWatermark,
+  atomicWrite,
+  SENTINEL_START,
+  SENTINEL_END,
+  HEADER,
+};

package/lib/core/navigation/edges.cjs

@@ -0,0 +1,86 @@
+'use strict';
+// Phase 125-00 -- navigation.cjs edge-write primitive (per CONTEXT.md Pass 3 GAP-2
+// resolution). Adds writeEdge to the navigation.cjs closed surface as an additive
+// extension following the Phase 110-03 logMemoryEvent precedent.
+//
+// Canon Part 4: every choice is graph data; this is the chokepoint primitive that
+// lets Plan 06 selector-decisions.cjs + future Phases 116/117/118 write typed
+// cascade edges without bypassing the closed surface.
+//
+// Canon Part 7: reuse-before-build -- the UPSERT statement mirrors
+// lib/core/lazygraph-ops.cjs::upsertEdge (lines 990-1019) so sibling agents
+// emit edges via the same UPSERT shape and the navigation chokepoint stays
+// the single door for write traffic.
+//
+// Canon Part 8 invariant: writeEdge takes (db, params) -- a db handle owned by
+// the caller (via openRoomDb) -- so this module never opens room.db itself. Zero
+// direct room-db.cjs require here. The navigation pre-commit hook treats this
+// file as part of the navigation/* allow-list, NOT as a bypass.
+
+const crypto = require('node:crypto');
+
+// Closed edge-type allowlist enforced by writeEdge. Mirrors the EVENT_TYPES Set
+// pattern in lib/core/navigation/memory-events.cjs. Phase 125 ships DEFERRED +
+// REJECTED (D7 typed cascade edge surface for F.1 defer / F.2 reject). Future
+// phases (e.g. Phase 116 tension resolution, Phase 117 auto-explore, Phase 118
+// MVA) extend this Set additively without canon amendment -- same idiom as the
+// EVENT_TYPES additive blocks for Phases 88.2-00 / 89-07 / 116-00 / 117-00 /
+// 110-02.
+//
+// Tests assert a FLOOR (DEFERRED + REJECTED present) and Set-instance shape --
+// not an exact size -- so additive extensions cannot regress baseline.
+const ALLOWED_EDGE_TYPES = Object.freeze(new Set([
+  // Phase 125 D7 -- F-selector decision edges (LOCKED LOCAL per Canon Part 8).
+  'DEFERRED',
+  'REJECTED',
+]));
+
+function isPlainObject(v) {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+// writeEdge(db, params) -- the 15th-style additive re-export on the
+// navigation.cjs closed surface (see navigation.cjs header comment for the
+// canonical re-export pattern alongside logMemoryEvent + firstCapturedLastTouchedBySection).
+//
+// Positional db (first arg, owned by caller via openRoomDb), params object
+// (second arg) with: { source_id, target_id, edge_type, properties }.
+//
+// Returns { ok: true, edge_id, type, source, target } on success, or
+// { ok: false, reason, detail? } on validation / write failure. Defensive --
+// never throws on caller input. The underlying prepare/run is sync per the
+// node:sqlite contract (matches the rest of the navigation module).
+function writeEdge(db, params) {
+  if (!params || typeof params !== 'object') {
+    return { ok: false, reason: 'invalid_params' };
+  }
+  const { source_id, target_id, edge_type, properties } = params;
+  if (typeof source_id !== 'string' || source_id.length === 0) {
+    return { ok: false, reason: 'invalid_source_id' };
+  }
+  if (typeof target_id !== 'string' || target_id.length === 0) {
+    return { ok: false, reason: 'invalid_target_id' };
+  }
+  if (typeof edge_type !== 'string' || !ALLOWED_EDGE_TYPES.has(edge_type)) {
+    return { ok: false, reason: 'invalid_edge_type', detail: String(edge_type).slice(0, 40) };
+  }
+  const props = isPlainObject(properties) ? properties : {};
+  let propsJson;
+  try {
+    propsJson = JSON.stringify(props);
+  } catch (_e) {
+    return { ok: false, reason: 'properties_serialize_failed' };
+  }
+  const edgeId = 'edge:' + edge_type + ':' + Date.now() + ':' + crypto.randomBytes(4).toString('hex');
+  try {
+    db.prepare(
+      'INSERT INTO edges (source, target, type, properties) VALUES (?, ?, ?, ?) ' +
+      'ON CONFLICT(source, target, type) DO UPDATE SET properties = excluded.properties'
+    ).run(source_id, target_id, edge_type, propsJson);
+  } catch (e) {
+    return { ok: false, reason: 'edge_write_failed', detail: String(e.message || '').slice(0, 80) };
+  }
+  return { ok: true, edge_id: edgeId, type: edge_type, source: source_id, target: target_id };
+}
+
+module.exports = { ALLOWED_EDGE_TYPES, writeEdge };

package/lib/core/navigation/insights.cjs

@@ -339,6 +339,42 @@ function findSurfaceableTensions(db, roomId, opts) {
   return candidates;
 }
 
+/**
+ * Phase 124-01 Plan: firstCapturedLastTouchedBySection
+ * ----------------------------------------------------
+ * For a given section slug (the source_section identity for a folder), return
+ * { first_captured_ms, last_touched_ms, total_events } across all memory_event
+ * rows scoped to that section (source_path === slug OR source_path LIKE slug/%).
+ *
+ * Used by lib/core/feynman/timeline-renderer.cjs for the D-05 summary line
+ * ("first captured {first_iso}, last touched {last_iso}"). Returns nulls + 0
+ * count when the section has zero memory_event rows -- the empty-state cue.
+ *
+ * Canon Part 9: pure SQL read against the local room.db; zero Brain surface;
+ * zero filesystem reads. Canon Part 8-safe by construction.
+ */
+function firstCapturedLastTouchedBySection(db, sectionSlug) {
+  if (!db || typeof db.prepare !== 'function' || typeof sectionSlug !== 'string' || sectionSlug.length === 0) {
+    return { first_captured_ms: null, last_touched_ms: null, total_events: 0 };
+  }
+  try {
+    const row = db.prepare(
+      "SELECT MIN(created_at) AS first_ms, MAX(created_at) AS last_ms, COUNT(*) AS n " +
+      "FROM nodes " +
+      "WHERE type = 'memory_event' " +
+      "AND (source_path = ? OR source_path LIKE ?)"
+    ).get(sectionSlug, sectionSlug + '/%');
+    const total = (row && Number.isFinite(row.n)) ? row.n : 0;
+    return {
+      first_captured_ms: total > 0 && Number.isFinite(row.first_ms) ? row.first_ms : null,
+      last_touched_ms: total > 0 && Number.isFinite(row.last_ms) ? row.last_ms : null,
+      total_events: total,
+    };
+  } catch (_) {
+    return { first_captured_ms: null, last_touched_ms: null, total_events: 0 };
+  }
+}
+
 module.exports = {
   findContradictions,
   findUnsupportedClaims,
@@ -347,4 +383,5 @@ module.exports = {
   findOpenQuestions,
   findRelevantOpportunities,
   findSurfaceableTensions,
+  firstCapturedLastTouchedBySection,
 };

package/lib/core/navigation/memory-events.cjs

@@ -47,13 +47,68 @@ const EVENT_TYPES = Object.freeze(new Set([
   //   fired (fingerprint detection -> spawn) -> finding_surfaced (drain -> F.1)
   //   -> user_response (Explore/Skip/Later/Free-text) OR skipped (suppression).
   //   brain_canon_drift_observed (FourLenses Brain vs FiveLenses Canon; emitted once per
-  //   session by 117-05 emitBrainCanonDrift via this EVENT_TYPES string; size 31 invariant).
+  //   session by 117-05 emitBrainCanonDrift via this EVENT_TYPES string).
+  // Size-invariant note: additive set; downstream phases extend (see the Phase 88.2-00,
+  // 89-07-00, 116-00, 117-00, 110-02 blocks). Tests assert a FLOOR + named membership,
+  // not an exact count -- so a future phase adding an event type cannot regress baseline.
   'auto_explore_fired',
   'auto_explore_finding_surfaced',
   'auto_explore_user_response',
   'auto_explore_skipped',
   'auto_explore_sanitizer_hit',
   'brain_canon_drift_observed',
+  // Phase 110-02 extension (Brain Context Packet Contract; D-07 + D-10 telemetry mirror):
+  //   brain_packet_rejected   -> an outbound packet failed in-schema validation in
+  //                              brain-client.sendPacket (reject hard -- thrown error).
+  //   brain_response_rejected -> a Brain response failed out-schema validation -> degraded
+  //                              soft, NOT ingested, no partial-ingest.
+  //   brain_legacy_path_used  -> the forward-looking deprecation guard fired (no current
+  //                              call site shipped in 110-02; see brain-client.cjs).
+  // Additive extension only; mirrors the Phase 116-00 5-tension-strings idiom and the
+  // 117-00 6-auto_explore-strings idiom. logEvent already rejects event_type values
+  // outside EVENT_TYPES -- so these are accepted only because they are now IN the Set.
+  'brain_packet_rejected',
+  'brain_response_rejected',
+  'brain_legacy_path_used',
+  // Phase 124-02 extension (FEYNMAN.md Temporal Awareness; D-10 telemetry mirror):
+  //   feynman_timeline_refreshed      -> the runner successfully rendered + wrote the
+  //                                      sentinel-bounded ## Timeline (auto) section for one
+  //                                      FEYNMAN.md (per section, per refresh).
+  //   feynman_timeline_refresh_failed -> the runner caught an exception during render or write;
+  //                                      watermark NOT updated; FEYNMAN.md NOT corrupted (atomic
+  //                                      .tmp write means the original is preserved on failure).
+  // Additive extension only; mirrors the Phase 110-02 3-string idiom verbatim. logEvent already
+  // rejects event_type values outside EVENT_TYPES -- so these are accepted only because they
+  // are now IN the Set. Set size grows by 2 (was 35 before Phase 124; now 37 baseline; coexists
+  // with the Phase 125-01 framework_invoked extension which adds +1 in parallel).
+  'feynman_timeline_refreshed',
+  'feynman_timeline_refresh_failed',
+  // Phase 125-01 extension (counter source for D3 continuous investment gradient).
+  // Each /mos:* methodology command run logs one framework_invoked event with payload
+  // {framework, command, timestamp}. computeInvestmentLevel(roomState) projects
+  // COUNT(memory_event WHERE event_type='framework_invoked') -> investment_level.
+  // The actual emission site is a follow-on instrumentation pass (lib/render/render-v2.cjs
+  // or per-command hook); Plan 01 only ships the event_type allowlist entry so
+  // computeInvestmentLevel can call findRecentChanges with this filter and get 0 (cold)
+  // back from a fresh room. The instrumentation is non-blocking for Plan 01 acceptance
+  // since computeInvestmentLevel reads from roomState.framework_invocations (which a
+  // separate caller will populate by calling findRecentChanges + counting); when no
+  // such count is available, the helper returns level: 0 -- the cold-start path.
+  'framework_invoked',
+  // Phase 125-06 extension (D7: F-selector reject/defer become typed graph signal).
+  // Emitted by lib/workflow/selector-decisions.cjs::recordSelectorDecision.
+  // Payload: {decision: 'defer'|'reject', command, framework, reason, edge_semantic,
+  //   expires_at|null, score_at_decision, investment_level_at_decision}. The corresponding
+  //   DEFERRED/REJECTED cascade edge is written via navigation.writeEdge (Plan 00).
+  //   Canon Part 4: every choice is graph data. The F-selector's adaptive-questioning
+  //   surface relies on this signal to apply decay-weight in subsequent rankings.
+  'f_selector_decision',
+  // Phase 125-07 extension (D8: none-fit affordance + ranker-miss capture).
+  // Emitted by lib/workflow/selector-decisions.cjs::recordSelectorMiss.
+  // Payload: {top_k_offered: [{command, score}, ...], user_intent: <verbatim user text>,
+  //   investment_level_at_decision}. NO cascade edge written (miss is temporal-only).
+  //   Canon Part 8: user_intent stays LOCAL; never sent to Brain.
+  'f_selector_miss',
 ]));
 
 function isPlainObject(v) {

package/lib/core/navigation/neighborhood.cjs

@@ -11,20 +11,20 @@
 // Canon Part 9: SELECT supersedes folder scanning; this is the load-bearing
 // query for the acceptance test.
 
-const NEIGHBORHOOD_SQL = "WITH RECURSIVE neighborhood(id, type, edge_path, depth, edge_type_in, last_seen_at, confidence, source_section, review_status, created_by, source_path) AS ( "
+const NEIGHBORHOOD_SQL = "WITH RECURSIVE neighborhood(id, type, edge_path, depth, edge_type_in, last_seen_at, created_at, confidence, source_section, review_status, created_by, source_path) AS ( "
   + "SELECT n.id, n.type, json_array(n.id) AS edge_path, 0 AS depth, NULL AS edge_type_in, "
-  + "n.last_seen_at, n.confidence, n.source_section, n.review_status, n.created_by, n.source_path "
+  + "n.last_seen_at, n.created_at, n.confidence, n.source_section, n.review_status, n.created_by, n.source_path "
   + "FROM nodes n WHERE n.id = :focus_node_id "
   + "UNION ALL "
   + "SELECT next_n.id, next_n.type, json_insert(nh.edge_path, '$[#]', next_n.id) AS edge_path, "
   + "nh.depth + 1 AS depth, e.type AS edge_type_in, "
-  + "next_n.last_seen_at, next_n.confidence, next_n.source_section, next_n.review_status, next_n.created_by, next_n.source_path "
+  + "next_n.last_seen_at, next_n.created_at, next_n.confidence, next_n.source_section, next_n.review_status, next_n.created_by, next_n.source_path "
   + "FROM neighborhood nh JOIN edges e ON e.source = nh.id JOIN nodes next_n ON next_n.id = e.target "
   + "WHERE nh.depth < :max_depth "
   + "AND json_array_length(nh.edge_path) < (:max_depth + 1) "
   + "AND nh.id != next_n.id "
   + ") "
-  + "SELECT id, type, edge_path, depth, edge_type_in, source_path, review_status, created_by, confidence, last_seen_at, "
+  + "SELECT id, type, edge_path, depth, edge_type_in, source_path, review_status, created_by, created_at, confidence, last_seen_at, "
   + "( "
   + "CASE edge_type_in "
   + "WHEN 'CONTRADICTS' THEN 1.0 "
@@ -70,6 +70,7 @@ function getNeighborhood(db, focusNodeId, opts) {
     sourcePath: r.source_path,
     reviewStatus: r.review_status,
     createdBy: r.created_by,
+    createdAt: r.created_at,
     confidence: r.confidence,
     lastSeenAt: r.last_seen_at,
   }));