@mindrian_os/cli 2.0.0-beta.3 → 2.0.0-beta.31

package/lib/core/expert-library.cjs

@@ -0,0 +1,303 @@
+'use strict';
+/*
+ * Phase 164-02 -- expert-library: library-first team assembly for the BONO engine
+ * (E1 / D-164-S1; 164-EXPERT-LIFECYCLE.md). With the SyntheticExpert writer shipped
+ * (synthetic-expert.cjs writeSyntheticExpertNode), this module is the CONSUMER: for
+ * each needed (hat, subdomain) slot, query CONFIRMED SyntheticExpert nodes, rank by
+ * the lifecycle score, slot a hit, return a generate-fresh marker on a miss. Team
+ * assembly QUERIES the library FIRST and generates ONLY the gaps, so BONO gets
+ * progressively cheaper and sharper while the anti-ossification guards keep new
+ * provocation entering every run.
+ *
+ * Canon Part 8 (the load-bearing constraint): ZERO Brain calls; ZERO raw room.db
+ *   open. Every read is a pure LOCAL graph walk over a caller-owned db handle (the
+ *   same contract as typed-domain.cjs / edges.cjs writeEdge / getNeighborhood: the
+ *   caller owns the handle (obtained through the room-db chokepoint); this module
+ *   NEVER requires room-db.cjs / node:sqlite / any brain client and NEVER opens
+ *   room.db itself).
+ *   All score inputs are LOCAL scalars. No venture content ever leaves the room.
+ * Canon Part 9: the ranking reader walks the graph via the navigation chokepoint
+ *   (getNeighborhood) for the survival walk; the mint-at-gate helper RETURNS a
+ *   candidate list (it does NOT call AskUserQuestion and does NOT promote) -- the
+ *   command surface renders the Shape F gate and the caller promotes via
+ *   navigation.confirmNode(byUser) (Part 9 role 5: the human decides).
+ * Canon Part 2 team discipline: the three anti-ossification guards
+ *   (164-EXPERT-LIFECYCLE.md section 3) are enforced in assembleTeam -- at least one
+ *   freshly-generated slot per run (the Green-hat mandatory-fresh rule), the Black
+ *   hat ALWAYS re-derived (adversarial freshness), and at most K of N slots filled
+ *   from the library (K < N) with a log() when the cap bites.
+ *
+ * NO em-dashes anywhere in this file (CLAUDE.md HARD RULE).
+ */
+
+const navigation = require('./navigation.cjs');
+
+// Evidence-tier rank (Canon Part 5): Academic 4 > Operational 3 > Practitioner 2 >
+// None 1. Normalized to [0,1] by /4 in the score so all four score terms share a
+// scale.
+const EVIDENCE_TIER_RANK = Object.freeze({
+  Academic: 4, Operational: 3, Practitioner: 2, None: 1,
+});
+
+// The lifecycle-score weights (164-EXPERT-LIFECYCLE.md section 1). Defaults tuned
+// here; a caller may override via opts.weights. w1 (evidence) and w2 (survival)
+// dominate; w3 (recency) is a gentle tie-breaker; w4 (staleness) is the penalty.
+const DEFAULT_WEIGHTS = Object.freeze({
+  w1: 0.40, // evidence_tier_rank (normalized)
+  w2: 0.35, // survival_rate (fraction of past rulings that survived)
+  w3: 0.15, // recency_decay(last_used) (exponential, newer = higher)
+  w4: 0.50, // staleness_penalty (subtracted; a stale expert is heavily penalized)
+});
+
+// The default reuse cap and the recency half-life (ms). A 30-day half-life mirrors
+// the Act 1 / stale-decision 30-day window used across the navigation insights.
+const DEFAULT_REUSE_CAP = 3;
+const RECENCY_HALF_LIFE_MS = 1000 * 60 * 60 * 24 * 30;
+
+function isPlainObject(v) {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+function parseProps(propsStr) {
+  if (isPlainObject(propsStr)) return propsStr;
+  if (typeof propsStr !== 'string' || propsStr.length === 0) return {};
+  try {
+    const p = JSON.parse(propsStr);
+    return isPlainObject(p) ? p : {};
+  } catch (_e) {
+    return {};
+  }
+}
+
+// recency_decay(last_used): exponential decay over the half-life. last_used is an
+// epoch-ms scalar; a 0/absent last_used decays to ~0 (never used recently).
+function recencyDecay(lastUsed, nowMs) {
+  if (!Number.isFinite(lastUsed) || lastUsed <= 0) return 0;
+  const ageMs = Math.max(0, nowMs - lastUsed);
+  return Math.pow(0.5, ageMs / RECENCY_HALF_LIFE_MS);
+}
+
+// survival_rate: a PURE navigation graph walk. Walk the expert's outgoing
+// STATES/SUPPORTS edges to its readings, then each reading's outgoing edges to past
+// rulings, and score the fraction that SURVIVED (a reading that INFORMS/VALIDATES a
+// ruling decision) vs was OVERRULED (a reading carrying a REJECTED_BECAUSE edge).
+// Reads via the navigation.getNeighborhood chokepoint (depth 2 from the expert),
+// NEVER raw SQL traversal. Returns a fraction in [0,1]; 0.5 when no ruling history
+// (neutral prior, neither rewarded nor punished).
+function computeSurvivalRate(db, expertId) {
+  let neighborhood;
+  try {
+    neighborhood = navigation.getNeighborhood(db, expertId, { maxDepth: 2, topK: 200 });
+  } catch (_e) {
+    return 0.5;
+  }
+  if (!Array.isArray(neighborhood) || neighborhood.length === 0) return 0.5;
+  let survived = 0;
+  let overruled = 0;
+  for (const n of neighborhood) {
+    // depth-2 nodes are the rulings the expert's readings reached; the edge_type_in
+    // that landed on them is the survival signal.
+    if (n.edgeTypeIn === 'REJECTED_BECAUSE') {
+      overruled += 1;
+    } else if (n.edgeTypeIn === 'INFORMS' || n.edgeTypeIn === 'VALIDATES' || n.edgeTypeIn === 'SUPPORTS') {
+      // a reading that fed (INFORMS/VALIDATES) a downstream ruling node survived.
+      if (n.type === 'decision' || n.type === 'claim' || n.type === 'CausalClaim') {
+        survived += 1;
+      }
+    }
+  }
+  const totalRulings = survived + overruled;
+  if (totalRulings === 0) return 0.5;
+  return survived / totalRulings;
+}
+
+// isExpertStale(db, expert, currentSubdomainHash): mirror the Act 1 source-hash
+// invalidation. expert.props.governing_thought_hash (the subdomain-claim-set hash
+// it was last validated against) compared to the current; mismatch -> stale.
+// Defensive: a missing currentSubdomainHash means "cannot judge", so NOT stale (do
+// not punish on a missing input). NEVER throws.
+function isExpertStale(db, expert, currentSubdomainHash) {
+  if (typeof currentSubdomainHash !== 'string' || currentSubdomainHash.length === 0) {
+    return false;
+  }
+  const props = expert && expert.props ? parseProps(expert.props) : {};
+  const recorded = typeof props.governing_thought_hash === 'string' ? props.governing_thought_hash : '';
+  if (recorded.length === 0) return false;
+  return recorded !== currentSubdomainHash;
+}
+
+// Match tier (164-EXPERT-LIFECYCLE.md section 1, most specific wins):
+//   1 exact hat + exact subdomain
+//   2 exact hat + same domain (different subdomain)
+//   3 exact hat + same archetype
+//   0 no tier match (excluded)
+function matchTier(props, slot) {
+  if (props.hat !== slot.hat) return 0;
+  if (slot.subdomain && props.subdomain === slot.subdomain) return 1;
+  if (slot.domain && props.domain === slot.domain) return 2;
+  if (slot.archetype && props.archetype === slot.archetype) return 3;
+  return 0;
+}
+
+// rankExpertsForSlot(db, {hat, subdomain, domain, archetype}, opts?): query CONFIRMED
+// SyntheticExpert nodes via the caller-owned db handle (a LOCAL read, no Brain, no
+// raw room.db open), bucket by the four match tiers, and within a tier score by the
+// documented formula. Returns a tier-then-score-ordered array; a miss returns [].
+function rankExpertsForSlot(db, slot, opts) {
+  if (!isPlainObject(slot) || typeof slot.hat !== 'string') return [];
+  const options = isPlainObject(opts) ? opts : {};
+  const w = isPlainObject(options.weights) ? options.weights : DEFAULT_WEIGHTS;
+  const nowMs = Number.isFinite(options.now) ? options.now : Date.now();
+  let rows;
+  try {
+    // LOCAL read over the caller-owned handle. Only CONFIRMED experts (Part 9 role
+    // 5: a proposed expert is not yet trusted, the human has not kept it).
+    rows = db.prepare(
+      "SELECT id, properties FROM nodes WHERE type = 'SyntheticExpert' AND review_status = 'confirmed'"
+    ).all();
+  } catch (_e) {
+    return [];
+  }
+  const scored = [];
+  for (const row of rows) {
+    const props = parseProps(row.properties);
+    const tier = matchTier(props, slot);
+    if (tier === 0) continue;
+    const evidenceRank = (EVIDENCE_TIER_RANK[props.evidence_tier] || 1) / 4;
+    const survivalRate = computeSurvivalRate(db, row.id);
+    const recency = recencyDecay(props.last_used, nowMs);
+    const stale = isExpertStale(db, { props }, slot.currentSubdomainHash);
+    const stalenessPenalty = stale ? 1 : 0;
+    const score = (w.w1 * evidenceRank)
+      + (w.w2 * survivalRate)
+      + (w.w3 * recency)
+      - (w.w4 * stalenessPenalty);
+    scored.push({
+      id: row.id,
+      hat: props.hat,
+      name: props.name,
+      surname: props.surname,
+      archetype: props.archetype,
+      subdomain: props.subdomain,
+      domain: props.domain,
+      evidenceTier: props.evidence_tier,
+      matchTier: tier,
+      survivalRate: survivalRate,
+      recency: recency,
+      stale: stale,
+      score: score,
+    });
+  }
+  // Most specific tier first; within a tier, highest score first.
+  scored.sort((a, b) => (a.matchTier - b.matchTier) || (b.score - a.score));
+  return scored;
+}
+
+// assembleTeam(db, {neededSlots, opts}): library-first assembly with the three
+// anti-ossification guards. For each (hat, subdomain) slot:
+//   - Black hat -> ALWAYS generate-fresh (adversarial freshness; never reuse).
+//   - else rankExpertsForSlot, skip stale, slot the top confirmed hit IF under the
+//     reuse cap K; else generate-fresh.
+// GUARANTEE at least one slot per run is generate-fresh (the mandatory-fresh rule);
+// if every non-Black slot got a hit, FORCE the lowest-ranked reuse back to fresh.
+// log() a reused-vs-generated summary, with a note when the cap bites.
+function assembleTeam(db, params) {
+  const p = isPlainObject(params) ? params : {};
+  const neededSlots = Array.isArray(p.neededSlots) ? p.neededSlots : [];
+  const opts = isPlainObject(p.opts) ? p.opts : {};
+  const reuseCap = Number.isInteger(opts.reuseCap) && opts.reuseCap >= 0 ? opts.reuseCap : DEFAULT_REUSE_CAP;
+  const log = typeof opts.log === 'function' ? opts.log : function noop() {};
+
+  const slots = [];
+  let reused = 0;
+  let capBit = false;
+
+  for (const slot of neededSlots) {
+    const s = isPlainObject(slot) ? slot : {};
+    const hat = typeof s.hat === 'string' ? s.hat : '';
+    // Guard 2: the Black hat is ALWAYS re-derived (never a library reuse).
+    if (hat === 'Black') {
+      slots.push({ hat: hat, subdomain: s.subdomain, action: 'generate-fresh', reason: 'black_always_fresh', reusedExpertId: null });
+      continue;
+    }
+    const ranked = rankExpertsForSlot(db, s, { weights: opts.weights, now: opts.now });
+    // skip stale candidates (freshness gate); take the top fresh, confirmed hit.
+    const hit = ranked.find((e) => !e.stale);
+    if (!hit) {
+      slots.push({ hat: hat, subdomain: s.subdomain, action: 'generate-fresh', reason: 'no_fresh_hit', reusedExpertId: null });
+      continue;
+    }
+    // Guard 3: reuse cap K of N. Under cap -> reuse; at/over cap -> generate-fresh.
+    if (reused < reuseCap) {
+      reused += 1;
+      slots.push({
+        hat: hat, subdomain: s.subdomain, action: 'reuse', reason: 'library_hit',
+        reusedExpertId: hit.id, score: hit.score, matchTier: hit.matchTier,
+      });
+    } else {
+      capBit = true;
+      slots.push({ hat: hat, subdomain: s.subdomain, action: 'generate-fresh', reason: 'reuse_cap_reached', reusedExpertId: null });
+    }
+  }
+
+  // Guard 1: the mandatory-fresh rule. If EVERY slot got reused (no generate-fresh
+  // anywhere), force the lowest-ranked reuse slot back to fresh so new provocation
+  // always enters. (Black already forces a fresh slot whenever a Black hat is in
+  // the run; this covers a run with no Black hat.)
+  const hasFresh = slots.some((sl) => sl.action === 'generate-fresh');
+  if (!hasFresh && slots.length > 0) {
+    let lowestIdx = -1;
+    let lowestScore = Infinity;
+    for (let i = 0; i < slots.length; i += 1) {
+      if (slots[i].action === 'reuse' && typeof slots[i].score === 'number' && slots[i].score < lowestScore) {
+        lowestScore = slots[i].score;
+        lowestIdx = i;
+      }
+    }
+    if (lowestIdx >= 0) {
+      slots[lowestIdx] = {
+        hat: slots[lowestIdx].hat, subdomain: slots[lowestIdx].subdomain,
+        action: 'generate-fresh', reason: 'mandatory_fresh_lens', reusedExpertId: null,
+      };
+      reused -= 1;
+    }
+  }
+
+  const generated = slots.filter((sl) => sl.action === 'generate-fresh').length;
+  const summary = { reused: reused, generated: generated, total: slots.length, reuseCap: reuseCap, capBit: capBit };
+  log('expert-library assembleTeam: reused=' + reused + ' generated=' + generated
+    + ' of ' + slots.length + (capBit ? ' (reuse cap K=' + reuseCap + ' bit)' : ''));
+
+  return { slots: slots, summary: summary };
+}
+
+// offerExpertsForFiling(runHats): the mint-at-Decision-Gate helper. Rank the run's
+// hats by contribution (evidence tier then survival rate) and RETURN the Shape F
+// gate candidate list. It does NOT call AskUserQuestion and does NOT promote; the
+// command surface renders the gate and the caller promotes APPROVE via
+// navigation.confirmNode(byUser) (Part 9 role 5). Pure, defensive, no db.
+function offerExpertsForFiling(runHats) {
+  if (!Array.isArray(runHats)) return [];
+  const candidates = runHats
+    .filter((h) => isPlainObject(h))
+    .map((h) => ({
+      hat: h.hat,
+      name: h.name,
+      surname: h.surname,
+      evidenceTier: h.evidenceTier,
+      survivalRate: Number.isFinite(h.survivalRate) ? h.survivalRate : 0,
+      contributionRank: ((EVIDENCE_TIER_RANK[h.evidenceTier] || 1) / 4) + (Number.isFinite(h.survivalRate) ? h.survivalRate : 0),
+    }));
+  candidates.sort((a, b) => b.contributionRank - a.contributionRank);
+  return candidates;
+}
+
+module.exports = {
+  rankExpertsForSlot,
+  isExpertStale,
+  assembleTeam,
+  offerExpertsForFiling,
+  computeSurvivalRate,
+  DEFAULT_WEIGHTS,
+  EVIDENCE_TIER_RANK,
+};

package/lib/core/exports-log.cjs

@@ -0,0 +1,79 @@
+/**
+ * MindrianOS Plugin -- Exports Log Operations
+ * Manages .exports-log.json in room directories for deployment tracking.
+ * Pure Node.js built-ins only (fs + path).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LOG_FILENAME = '.exports-log.json';
+
+/**
+ * Read the exports log from a room directory.
+ * Returns { deployments: [] } if file is missing or malformed.
+ * @param {string} roomDir - Path to room directory
+ * @returns {{ deployments: Array<object> }}
+ */
+function readExportsLog(roomDir) {
+  const logPath = path.join(roomDir, LOG_FILENAME);
+  try {
+    const raw = fs.readFileSync(logPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.deployments)) {
+      return { deployments: [] };
+    }
+    return parsed;
+  } catch {
+    return { deployments: [] };
+  }
+}
+
+/**
+ * Append a deployment entry to the exports log.
+ * Entry shape: { url, timestamp, host, sections, private, project_name }
+ * @param {string} roomDir - Path to room directory
+ * @param {object} entry - Deployment entry
+ * @param {string} entry.url - Deployed URL
+ * @param {string} [entry.timestamp] - ISO timestamp (defaults to now)
+ * @param {string} [entry.host] - Hosting provider (default: "vercel")
+ * @param {string[]} [entry.sections] - Sections deployed (default: ["all"])
+ * @param {boolean} [entry.private] - Whether password-protected (default: false)
+ * @param {string} [entry.project_name] - Vercel project name
+ * @param {string} [entry.password] - Password if private deployment
+ * @returns {object} The entry that was logged
+ */
+function logDeployment(roomDir, entry) {
+  const log = readExportsLog(roomDir);
+  const fullEntry = {
+    url: entry.url || '',
+    timestamp: entry.timestamp || new Date().toISOString(),
+    host: entry.host || 'vercel',
+    sections: entry.sections || ['all'],
+    private: entry.private || false,
+    project_name: entry.project_name || '',
+  };
+  // Include password only if private
+  if (entry.private && entry.password) {
+    fullEntry.password = entry.password;
+  }
+  log.deployments.push(fullEntry);
+  const logPath = path.join(roomDir, LOG_FILENAME);
+  fs.writeFileSync(logPath, JSON.stringify(log, null, 2) + '\n', 'utf-8');
+  return fullEntry;
+}
+
+/**
+ * Get the most recent deployment entry, or null if none.
+ * @param {string} roomDir - Path to room directory
+ * @returns {object|null}
+ */
+function getLatestDeployment(roomDir) {
+  const log = readExportsLog(roomDir);
+  if (log.deployments.length === 0) return null;
+  return log.deployments[log.deployments.length - 1];
+}
+
+module.exports = { readExportsLog, logDeployment, getLatestDeployment };

package/lib/core/feynman/ROOM.md

@@ -0,0 +1,25 @@
+# lib/core/feynman/
+
+Phase 124 (FEYNMAN.md temporal awareness) renderer + runner ship here.
+
+Contains (after Plans 124-01 and 124-02 land):
+- `timeline-renderer.cjs` -- pure function `renderTimeline(db, sectionSlug, opts) -> { markdown_body, summary_stats }`. Reads ONLY via `lib/core/navigation.cjs` (the Phase 109 closed chokepoint): `findRecentChanges`, `findStaleDecisions`, and the new `firstCapturedLastTouchedBySection` (added as the 15th re-export in Plan 124-01, mirroring the Phase 110-03 `logMemoryEvent` re-export idiom). ZERO filesystem reads. ZERO Brain calls. ZERO LLM calls.
+- `timeline-runner.cjs` -- `refreshAll(roomDir)` + `refreshSection(roomDir, sectionSlug)`. Walks the room's section folders, finds each `FEYNMAN.md` with the sentinel pair (creates the pair if absent on first run), reads the surrounding body, calls the renderer, writes the file back with the body byte-preserved and the sentinel-bounded section replaced, sets `timeline_last_rendered: <ISO>` frontmatter (second-resolution). Each refresh logs a `memory_event` of type `feynman_timeline_refreshed`. Idempotent (re-run -> byte-identical output).
+
+Sentinel pair (D-02 hard invariant; bytes outside the pair are byte-preserved across regeneration):
+- `<!-- TIMELINE_AUTO_START -->`
+- `<!-- TIMELINE_AUTO_END -->`
+
+Stale thresholds (D-06; overridable via `process.env.MINDRIAN_TIMELINE_THRESHOLDS_JSON` for tests):
+- recent < 7 days
+- quiet 7-30 days
+- stale 30-90 days
+- dormant > 90 days
+
+Owner: Phase 124 FEYNMAN.md Temporal Awareness.
+Canon: Part 9 (the Larry-explains face of memory_event). Renderer reads ONLY room.db via navigation.cjs (D-03). Writes ONLY FEYNMAN.md inside the sentinels (D-02 hard invariant).
+Boundary: NO Brain calls (Canon Part 8); NO filesystem reads outside the FEYNMAN.md being written and the room.db family (allow-list pattern enforced by `tests/test-feynman-timeline-canon-part-9-invariant.cjs`).
+
+Upstream: `lib/core/navigation.cjs` (Phase 109 chokepoint), `lib/core/navigation/memory-events.cjs` (EVENT_TYPES +2 in Plan 124-02), `lib/core/navigation/insights.cjs` (source_section provenance).
+
+See: `.planning/phases/124-feynman-temporal-awareness/124-CONTEXT.md`.

package/lib/core/feynman/dial-memory-renderer.cjs

@@ -0,0 +1,279 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 143.1-05 -- dial-memory renderer (MEMDIAL-02 / MEMDIAL-03).
+ * ================================================================
+ * The legible MD projection of the dial relationship layer. A PURE function
+ *   renderDialMemory(db, sectionSlug, opts) -> { markdown_body, summary_stats }
+ * modeled VERBATIM on the SHIPPED Phase 124 timeline-renderer architecture
+ * (lib/core/feynman/timeline-renderer.cjs): it reads ONLY via lib/core/navigation.cjs
+ * (the Phase 109 closed chokepoint, D-03), with ZERO filesystem reads and ZERO
+ * Brain calls.
+ *
+ * The section is rendered FROM the graph (MEMDIAL-03; the graph is the source of
+ * truth, the MD is the legible projection) and carries ALL FOUR MEMDIAL-02
+ * components on every render:
+ *
+ *   1. Available reaches      -- the 6 canonical reach ids (DIAL_REACH_K doctrine; Phase 148 D-09 raised 5 -> 6).
+ *   2. Last selected          -- the most-recent SELECTED_REACH edge, surfaced via
+ *                                navigation.getNeighborhood off the focus node.
+ *   3. Current recommended    -- the FROZEN-gate result, passed in via opts.reachList
+ *                                (the dial-reach orchestrator's pre-baked LOCAL output;
+ *                                this renderer never re-runs the gate -- it projects).
+ *   4. Recent research conclusions -- surfaced from the DRSCH research-conclusion
+ *                                evidence edges via navigation.getNeighborhood filtered
+ *                                on the DRSCH / evidence-conclusion edgeTypeIn
+ *                                (EvidenceClaim-typed neighbors reached by an INFORMS
+ *                                edge). Rendered as a clean empty/placeholder block
+ *                                ("no recent research conclusions") when none exist --
+ *                                NEVER omitted, NEVER a crash.
+ *
+ * Idempotence (MEMDIAL-03): rendering twice from the same graph state yields a
+ * byte-identical body (deterministic sort, ISO-second timestamps, frozen format).
+ *
+ * The renderer ALSO exports the dial sentinels + a mergeDialSection helper so the
+ * runner (Plan 143.1-05 Task 3) can do its sentinel-bounded byte-preserving write
+ * without re-deriving the contract. The merge idiom mirrors the Phase 124
+ * timeline-runner mergeSentinelSection verbatim (Part 7 reuse).
+ *
+ * Canon Part 8: zero net-new Brain surface; LOCAL-only projection of the LOCAL
+ *   graph. Canon Part 9: SQL is the source of truth; this is the Larry-explains
+ *   face of the SELECTED_REACH / PIVOTED / DRSCH relationship layer.
+ *
+ * NO em-dashes / en-dashes anywhere (CLAUDE.md HARD RULE). Hyphens only.
+ *
+ * License: BSL 1.1.
+ */
+
+const navigation = require('../navigation.cjs');
+const { REACH_IDS } = require('../../hmi/dial-reach-orchestrator.cjs');
+
+// ---------- Dial sentinel contract (mirrors the Phase 124 D-02 idiom) ----------
+
+const SENTINEL_START = '<!-- DIAL_MEMORY_AUTO_START -->';
+const SENTINEL_END = '<!-- DIAL_MEMORY_AUTO_END -->';
+const HEADER = '## Dial Memory (auto)';
+
+// How far back the graph traversal reaches for the dial relationship layer. A
+// generous neighborhood so SELECTED_REACH + DRSCH neighbors all surface; the
+// renderer filters by edge type after the traversal.
+const NEIGHBORHOOD_TOP_K = 200;
+const NEIGHBORHOOD_MAX_DEPTH = 2;
+
+// ---------- ISO helper (second resolution -- idempotence) ----------
+
+function isoSecond(ms) {
+  if (!Number.isFinite(ms)) return '';
+  return new Date(ms).toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+
+// ---------- Graph reads (ONLY via navigation.cjs) ----------
+
+// Pull the full neighborhood off the focus node, then filter by edge type. The
+// SELECTED_REACH neighbors are committed reaches; the EvidenceClaim neighbors
+// reached by an INFORMS edge are the DRSCH research-conclusion evidence layer.
+function neighborhood(db, focusNodeId) {
+  if (!focusNodeId) return [];
+  try {
+    return navigation.getNeighborhood(db, focusNodeId, {
+      topK: NEIGHBORHOOD_TOP_K,
+      maxDepth: NEIGHBORHOOD_MAX_DEPTH,
+    }) || [];
+  } catch (_) {
+    return [];
+  }
+}
+
+// The most-recent SELECTED_REACH neighbor (the "last selected" component). The
+// neighbor's id is cmd:<command>; the edgeTypeIn is SELECTED_REACH.
+function lastSelected(neighbors) {
+  const selected = neighbors.filter((n) => n.edgeTypeIn === 'SELECTED_REACH');
+  if (selected.length === 0) return null;
+  // Deterministic: newest createdAt first; tie-break on id for idempotence.
+  selected.sort((a, b) => {
+    const ca = Number.isFinite(a.createdAt) ? a.createdAt : 0;
+    const cb = Number.isFinite(b.createdAt) ? b.createdAt : 0;
+    if (cb !== ca) return cb - ca;
+    return String(a.id).localeCompare(String(b.id));
+  });
+  return selected[0];
+}
+
+// The DRSCH research-conclusion evidence neighbors: EvidenceClaim-typed nodes
+// reached via an INFORMS edge (the FILEVAL-02 substrate's evidence-conclusion
+// edgeTypeIn). Deterministic order: newest first, tie-break on id.
+function researchConclusions(neighbors) {
+  const drsch = neighbors.filter((n) =>
+    n.type === 'EvidenceClaim' && n.edgeTypeIn === 'INFORMS');
+  drsch.sort((a, b) => {
+    const ca = Number.isFinite(a.createdAt) ? a.createdAt : 0;
+    const cb = Number.isFinite(b.createdAt) ? b.createdAt : 0;
+    if (cb !== ca) return cb - ca;
+    return String(a.id).localeCompare(String(b.id));
+  });
+  return drsch;
+}
+
+// Strip the opaque "EvidenceClaim:<session>:" prefix to a readable handle so the
+// rendered line is legible without leaking raw provenance. The renderer reads
+// only what getNeighborhood returns (the node id); it never opens room.db to
+// fetch the topic blob.
+function readableEvidenceHandle(id) {
+  const s = String(id || '');
+  const m = s.match(/^EvidenceClaim:[^:]*:(.+)$/);
+  return m ? m[1] : s;
+}
+
+// The current-recommended component reads the FROZEN-gate result the caller
+// already computed (opts.reachList from the dial-reach orchestrator). This
+// renderer NEVER re-runs the gate; it projects what the graph + the pre-baked
+// LOCAL signal produced.
+function recommendedReaches(reachList) {
+  if (!reachList || !Array.isArray(reachList.reaches)) return [];
+  return reachList.reaches.filter((r) => r && r.recommended === true);
+}
+
+// ---------- The renderer ----------
+
+function renderDialMemory(db, sectionSlug, opts) {
+  const options = opts || {};
+  const now_ms = Number.isFinite(options.now_ms) ? options.now_ms : Date.now();
+  const focusNodeId = typeof options.focusNodeId === 'string' && options.focusNodeId.length > 0
+    ? options.focusNodeId
+    : ('section:' + sectionSlug);
+  const reachList = (options.reachList && typeof options.reachList === 'object')
+    ? options.reachList
+    : { reaches: [], tier_mode: 'tier_0' };
+
+  const neighbors = neighborhood(db, focusNodeId);
+  const sel = lastSelected(neighbors);
+  const drsch = researchConclusions(neighbors);
+  const recommended = recommendedReaches(reachList);
+
+  const lines = [];
+  const nowIso = isoSecond(now_ms);
+
+  // Empty state (MEMDIAL-02): zero SELECTED_REACH edges -> clean, intentional.
+  if (!sel) {
+    lines.push('*Last refreshed: ' + nowIso + '. No dial activity yet.*');
+    lines.push('');
+    lines.push('**Available reaches** (' + REACH_IDS.length + '):');
+    for (const rid of REACH_IDS) lines.push('- ' + rid);
+    lines.push('');
+    lines.push('**Last selected:** none yet.');
+    lines.push('');
+    lines.push('**Current recommended:** ' + renderRecommended(recommended, reachList));
+    lines.push('');
+    lines.push('**Recent research conclusions:**');
+    lines.push(renderResearchBlock(drsch));
+    return {
+      markdown_body: lines.join('\n'),
+      summary_stats: {
+        available_reaches: REACH_IDS.length,
+        selected_count: 0,
+        recommended_count: recommended.length,
+        research_conclusions: drsch.length,
+      },
+    };
+  }
+
+  // Populated state: all 4 components.
+  lines.push('*Last refreshed: ' + nowIso + '. Dial activity tracked as a typed graph relationship layer.*');
+  lines.push('');
+
+  // Component 1: available reaches.
+  lines.push('**Available reaches** (' + REACH_IDS.length + '):');
+  for (const rid of REACH_IDS) lines.push('- ' + rid);
+  lines.push('');
+
+  // Component 2: last selected (the most-recent SELECTED_REACH edge).
+  const selCmd = String(sel.id || '').replace(/^cmd:/, '');
+  lines.push('**Last selected:** ' + selCmd + ' (selected ' + isoSecond(sel.createdAt) + ').');
+  lines.push('');
+
+  // Component 3: current recommended (the FROZEN-gate result).
+  lines.push('**Current recommended:** ' + renderRecommended(recommended, reachList));
+  lines.push('');
+
+  // Component 4: recent research conclusions (DRSCH-surfaced; empty/placeholder).
+  lines.push('**Recent research conclusions:**');
+  lines.push(renderResearchBlock(drsch));
+
+  return {
+    markdown_body: lines.join('\n'),
+    summary_stats: {
+      available_reaches: REACH_IDS.length,
+      selected_count: neighbors.filter((n) => n.edgeTypeIn === 'SELECTED_REACH').length,
+      recommended_count: recommended.length,
+      research_conclusions: drsch.length,
+    },
+  };
+}
+
+// Render the current-recommended component. The dial is the confidence column;
+// here it degrades to a legible list of the gated reach ids (the section is a
+// memory projection, not the interactive chooser).
+function renderRecommended(recommended, reachList) {
+  const tier = reachList && typeof reachList.tier_mode === 'string' ? reachList.tier_mode : 'tier_0';
+  if (!recommended || recommended.length === 0) {
+    if (tier !== 'mode_a') {
+      return 'none (Brain-gated marker is a mode_a concept; current tier ' + tier + ').';
+    }
+    return 'none above the frozen 0.70 gate.';
+  }
+  const ids = recommended
+    .map((r) => String(r.reach_id || ''))
+    .filter((s) => s.length > 0)
+    .sort();
+  return ids.join(', ') + '.';
+}
+
+// Render the research-conclusions block. ALWAYS returns a non-empty string: a
+// clean placeholder when no DRSCH edges exist (so the block is never omitted and
+// never crashes), or one line per surfaced research conclusion.
+function renderResearchBlock(drsch) {
+  if (!drsch || drsch.length === 0) {
+    return '- no recent research conclusions';
+  }
+  const out = [];
+  for (const n of drsch) {
+    out.push('- ' + readableEvidenceHandle(n.id));
+  }
+  return out.join('\n');
+}
+
+// ---------- Sentinel-bounded merge (mirrors Phase 124 mergeSentinelSection) ----------
+
+function mergeDialSection(body, renderedBody) {
+  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;
+  }
+  const sep = body.endsWith('\n') ? '' : '\n';
+  return body + sep + '\n' + HEADER + '\n\n' + SENTINEL_START + '\n' + renderedBody + '\n' + SENTINEL_END + '\n';
+}
+
+function bodyOutsideSentinels(body) {
+  const startIdx = body.indexOf(SENTINEL_START);
+  const endIdx = body.indexOf(SENTINEL_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return body;
+  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);
+}
+
+module.exports = {
+  renderDialMemory,
+  mergeDialSection,
+  bodyOutsideSentinels,
+  isoSecond,
+  SENTINEL_START,
+  SENTINEL_END,
+  HEADER,
+};