neurain 0.1.0-alpha.7 → 0.1.0-alpha.9

package/CHANGELOG.md

@@ -4,6 +4,16 @@
 
 - No unreleased changes recorded.
 
+## 0.1.0-alpha.9
+
+- Output consistency (single render source): added `src/core/render.mjs` as the one place that renders user-facing command output, so every host shows the same block. `status`, `compile`, `sync`, and `capture` now build their output via `renderX(payload)`, expose it as `payload.rendered`, and return it as `{ text }` (the existing `digest.mjs` pattern). The MCP server's user-facing view tools (`neurain_session_status`, `neurain_compile`, `neurain_digest_preview`) now return that rendered markdown block instead of `JSON.stringify(payload)`, so an MCP host and the CLI emit byte-identical bytes; diagnostic/eval MCP tools still return JSON. Output is clean GitHub-flavored markdown tables, ASCII only, with status as words (ok/warn/missing/blocked) and no status glyphs or dashes. The `--json` payload shape is unchanged (machine consumers unaffected). Added `test/render.test.mjs` (per-renderer ascii/table/determinism, CLI-text == payload.rendered, MCP returns markdown not JSON). npm test 167/167, readiness 100.
+
+
+## 0.1.0-alpha.8
+
+- Privacy (exact recall freshness): the exact-token branch reads from the SQLite FTS index, which is a cache rebuilt only on demand, so a markdown file that was public when indexed but has since turned `sensitivity: private`, been deleted, or gained a secret could linger in `recall search` and `hybrid-search` exact results until the next rebuild. `searchRecall` now re-gates the returned markdown paths against the CURRENT files (same private/secret/exists gate the markdown branches already apply) and drops any that are no longer safe. Only the top-K returned paths are re-read, so the exact branch stays fast (~4ms warm); a fresh index drops nothing, so results are unchanged (golden 9/9 identical). Event and receipt rows keep their own collection-time gating and pass through. Added `test/perf_recall_equivalence.test.mjs` coverage that a public-then-private and a deleted file do not surface from a stale index.
+
+
 ## 0.1.0-alpha.7
 
 - Hardening (recall perf, from an adversarial review): lock the "byte-identical results" claim and tighten the fast-path contracts, with no change to ranking/scores (golden-identical).

package/README.md

@@ -204,7 +204,7 @@ It exposes read/capture/scan/preview tools only. It does not silently compile, p
 
 ## Status
 
-This is `0.1.0-alpha.7`. It is not a public SaaS GA release. The alpha exists to prove installability, local-first onboarding, Codex, Claude, Gemini, and Runtime connectivity, plus safety receipts.
+This is `0.1.0-alpha.9`. It is not a public SaaS GA release. The alpha exists to prove installability, local-first onboarding, Codex, Claude, Gemini, and Runtime connectivity, plus safety receipts.
 
 Alpha publish command:
 

package/docs/development-status.en.md

@@ -1,9 +1,9 @@
 # Development Status
 
 Version: v0.1
-Last updated: 2026-06-20 KST
-Package: `neurain@0.1.0-alpha.7`
-Latest documented commit: `18bbb9f perf(recall): lock byte-identical claim in CI + harden fast-path contracts`
+Last updated: 2026-06-21 KST
+Package: `neurain@0.1.0-alpha.9`
+Latest documented commit: `291ba2e feat(render): single engine render source; MCP relays rendered markdown`
 
 This document is the canonical product development snapshot for the public package. It tracks what is shipped, what has evidence, and what must not be claimed yet.
 

package/docs/development-status.kr.md

@@ -1,9 +1,9 @@
 # 개발 진행 상태
 
 Version: v0.1
-Last updated: 2026-06-20 KST
-Package: `neurain@0.1.0-alpha.7`
-Latest documented commit: `18bbb9f perf(recall): lock byte-identical claim in CI + harden fast-path contracts`
+Last updated: 2026-06-21 KST
+Package: `neurain@0.1.0-alpha.9`
+Latest documented commit: `291ba2e feat(render): single engine render source; MCP relays rendered markdown`
 
 이 문서는 public package 기준의 canonical 개발 상태 스냅샷입니다. 무엇이 shipped인지, 어떤 증거가 있는지, 아직 주장하면 안 되는 것이 무엇인지 함께 기록합니다.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neurain",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.9",
   "description": "Local-first Neurain Knowledge OS CLI and MCP connector.",
   "type": "module",
   "license": "Apache-2.0",

package/src/core/capture_durable.mjs

@@ -21,6 +21,7 @@ import { firstLineTitle, inferFlushLevelFromEnvelope, inferTargetLayerFromIntent
 import { resolveCanonicalPath } from './resolve_target.mjs';
 import { folderForSourceType, makeEnvelope, readArgInput, renderCaptureMarkdown, slugify } from './envelope.mjs';
 import { withFileLock, atomicWriteJson } from './durable.mjs';
+import { renderSave } from './render.mjs';
 import { stageAndPromote } from './stage.mjs';
 import { loadSessionState, pendingCountForSession } from './vault_state.mjs';
 import { appendWikiLog } from './wiki_log.mjs';
@@ -242,27 +243,7 @@ export async function captureCommand(args) {
 }
 
 function done(args, payload) {
+  payload.rendered = renderSave(payload);
   if (args.json) return { json: true, payload };
-  if (!payload.ok) {
-    if (payload.refused) {
-      const lines = [`⛔ BLOCKED (secret): ${payload.reason}`];
-      for (const h of payload.hits || []) lines.push(`    [${h.confidence}] ${h.type}: ${h.sample}`);
-      return { text: lines.join('\n') };
-    }
-    return { text: `# Capture\n\n- ${payload.error}` };
-  }
-  if (payload.dry_run) {
-    const e = payload.envelope;
-    const lines = [`# Capture Dry Run`, '', `- Source ID: ${e.source_id}`, `- Raw path: ${e.raw_path}`, `- Areas: ${e.area_candidates.join(', ') || 'none'}`, `- Sensitivity: ${e.sensitivity}`, `- Intent: ${e.write_intent}`, `- Requires user decision: ${e.requires_user_decision ? 'yes' : 'no'}`];
-    if (payload.duplicate_of) lines.push(`- Duplicate of: ${payload.duplicate_of.source_id} (${payload.duplicate_of.raw_path})`);
-    if (e.extracted_text_chars != null) lines.push(`- Extracted text: ${e.extracted_text_chars} chars via ${e.extracted_method}`);
-    if (e.overlap_candidates) lines.push(`- Overlaps existing: ${e.overlap_candidates.map((o) => o.path).join(', ')}`);
-    if (e.numeric_conflict_candidates) lines.push(`- Numeric review (${e.numeric_conflict_candidates.length}): ${e.numeric_conflict_candidates.slice(0, 3).map((n) => `${n.label} new=${n.new_values.join('/')} vs existing=${n.existing_value}`).join('; ')}`);
-    return { text: lines.join('\n') };
-  }
-  const lines = ['# Captured', '', `- Source ID: ${payload.source_id}`, `- Raw path: ${payload.raw_path}`];
-  if (payload.asset_path) lines.push(`- Raw asset: ${payload.asset_path}`);
-  lines.push(`- Envelope: ${payload.envelope_path}`, `- Requires user decision: ${payload.requires_user_decision ? 'yes' : 'no'}`);
-  if (payload.session_state_delta) lines.push(`- Session-state delta (unapplied, pending_count=${payload.session_state_delta.patch.pending_count}) returned for the vault shuttle.`);
-  return { text: lines.join('\n') };
+  return { text: payload.rendered };
 }

package/src/core/compile_desk.mjs

@@ -10,6 +10,7 @@ import { absPath, timestamp } from './fs.mjs';
 import { vaultConfig } from './config.mjs';
 import { resolveCanonicalPath } from './resolve_target.mjs';
 import { readJsonSafe, readJsonl } from './vault_state.mjs';
+import { renderCompile } from './render.mjs';
 
 function manifestEntries(value) {
   return Object.values((value && value.files) || {});
@@ -310,32 +311,7 @@ export async function compileCommand(args) {
         : 'No safe compile target was selected. This desk shows candidates and does not read raw bodies.',
   };
 
+  payload.rendered = renderCompile(payload);
   if (args.json) return { json: true, payload };
-  return { text: render(payload) };
-}
-
-function render(value) {
-  const lines = ['# Neurain Compile Desk', ''];
-  lines.push(`- Mode: ${value.mode}`);
-  lines.push(`- Pending queue: ${value.queue.pending_count}`);
-  lines.push(`- Safe queue: ${value.queue.safe_count}`);
-  lines.push(`- Needs confirmation: ${value.queue.needs_confirmation_count}`);
-  lines.push(`- Deep compile candidates: ${value.source_digest.deep_compile_candidate_count}`);
-  lines.push(`- Raw full reads allowed: ${value.performance_policy.raw_full_reads_allowed}`);
-  if (value.candidates && value.candidates.length) {
-    lines.push('', `## Candidates (priority order): ${value.candidates.length}`);
-    for (const c of value.candidates) {
-      lines.push(`  ${c.rank}. [${c.priority}] ${c.title || c.source_id || c.kind}${c.source_id ? `  (${c.source_id})` : ''}`);
-    }
-  }
-  if (value.excluded && value.excluded.length) {
-    lines.push('', `제외(확인필요/비공개) ${value.excluded.length}건: ${value.excluded.map((e) => e.title || e.source_id).join(', ')}`);
-  }
-  if (value.candidates && value.candidates.length) {
-    lines.push('', '몇 건 정리할까요? (숫자 1–10; "전부"는 안전한 것 최대 10건 + 나머지 개수 공시)');
-  } else if (!value.selected_target && value.excluded && value.excluded.length) {
-    lines.push('', '정리 가능한 안전 후보가 없습니다. 위 제외 항목은 확인/승인 후에만 처리됩니다.');
-  }
-  lines.push(`- Next action: ${value.next_action}`);
-  return lines.join('\n');
+  return { text: payload.rendered };
 }

package/src/core/recall.mjs

@@ -7,7 +7,7 @@ import { inferSensitivityFromPath } from './safety.mjs';
 import { alternativeForm, getProvider, tokenize } from './semantic.mjs';
 import { recallConfig } from './config.mjs';
 import { createSensitivityResolver } from './labels.mjs';
-import { kindForPath, listRecallMarkdownFiles, recallConfigErrors, resolveAreaDir, safeToIndex, scopeForArea, scopeForPath, titleForText } from './recall_corpus.mjs';
+import { filterCurrentlySafePaths, kindForPath, listRecallMarkdownFiles, recallConfigErrors, resolveAreaDir, safeToIndex, scopeForArea, scopeForPath, titleForText } from './recall_corpus.mjs';
 import { buildLexicalContext, lexicalSearchWithContext } from './recall_lexical.mjs';
 import { benchRecall, scorecardRecall } from './recall_bench.mjs';
 
@@ -158,17 +158,28 @@ export async function searchRecall(root, query, { top = 10, host = '', fallback
       ORDER BY rank ASC, d.path ASC
       LIMIT ?
     `).all(ftsQuery, String(host || ''), String(host || ''), scopeFilter, scopeFilter, limit);
-    payload.results = rows.map((row) => ({
-      path: row.path,
-      kind: row.kind,
-      host: row.host,
-      scope: row.scope,
-      sensitivity: row.sensitivity,
-      title: row.title,
-      snippet: row.snippet,
-      source_hash: row.source_hash,
-      score: Number((-Number(row.rank || 0)).toFixed(3)),
-    }));
+    // The FTS index is a cache rebuilt only on demand, so re-gate the returned MARKDOWN
+    // paths against the CURRENT files: drop any row whose file has since turned private,
+    // been deleted, gained a secret, or left the corpus. Only the top-K paths are
+    // re-read, so the exact branch stays fast while never surfacing stale-private or
+    // deleted content. A fresh index drops nothing (results unchanged). Event/receipt
+    // rows use synthetic paths (a '#event' suffix or a non-.md receipt path) and carry
+    // their own collection-time gating, so they pass through unchanged.
+    const isMarkdownRow = (p) => p.endsWith('.md') && !p.includes('#');
+    const stillSafe = filterCurrentlySafePaths(root, recallConfig(root), rows.map((row) => row.path).filter(isMarkdownRow));
+    payload.results = rows
+      .filter((row) => !isMarkdownRow(row.path) || stillSafe.has(row.path))
+      .map((row) => ({
+        path: row.path,
+        kind: row.kind,
+        host: row.host,
+        scope: row.scope,
+        sensitivity: row.sensitivity,
+        title: row.title,
+        snippet: row.snippet,
+        source_hash: row.source_hash,
+        score: Number((-Number(row.rank || 0)).toFixed(3)),
+      }));
   } catch (error) {
     payload.ok = false;
     payload.error = error.message;

package/src/core/recall_corpus.mjs

@@ -150,3 +150,29 @@ export function listRecallMarkdownFiles(root, recallCfg, { area = '' } = {}) {
   }
   return out;
 }
+
+// Re-verify, against the CURRENT files, that specific paths still belong in the
+// recall corpus right now (in-corpus + exists + not private + not secret/injection).
+// The exact-token branch reads from a SQLite cache that is only rebuilt explicitly,
+// so a file that was public when indexed but has since turned private or been
+// deleted could otherwise linger in exact results until the next rebuild. Applying
+// this same gate to the returned paths closes that staleness window. It re-reads
+// only the handful of returned paths (top-K), not the whole corpus, so the exact
+// branch stays fast. Returns a Set of the still-safe paths.
+export function filterCurrentlySafePaths(root, recallCfg, rels) {
+  const resolver = createSensitivityResolver(root, recallCfg);
+  const matches = buildRecallPathMatcher(recallCfg);
+  const safe = new Set();
+  for (const rel of rels) {
+    if (safe.has(rel)) continue;
+    if (!matches(rel)) continue;
+    if (!isTextFile(rel)) continue;
+    const abs = path.join(root, rel);
+    if (!fs.existsSync(abs)) continue;
+    const text = readText(abs, '');
+    if (resolver.sensitivityFor(rel, text) === 'private') continue;
+    if (!safeToIndex(text)) continue;
+    safe.add(rel);
+  }
+  return safe;
+}

package/src/core/render.mjs

@@ -0,0 +1,179 @@
+// Single source of truth for user-facing command rendering.
+//
+// Every five-command output (and the read-only views) is produced HERE as one
+// deterministic markdown block, then exposed by each command-function as
+// `payload.rendered` AND `{ text }` (the digest.mjs pattern). The CLI, the MCP
+// server, and the vault shuttles all relay that SAME string verbatim, so the
+// output is byte-identical across every host (Claude Code, Codex, Gemini).
+//
+// Rules that keep the bytes host-identical and clean:
+//   - pure functions (payload -> string), no Date.now / no I/O. Timestamps and
+//     ids arrive already stamped in the payload.
+//   - GitHub-flavored markdown tables only, ASCII characters only. Status is a
+//     word (ok / warn / missing / blocked / none / yes / no), never a glyph.
+//     No status glyphs and no em/en dashes (the operating contract bans them and
+//     a determinism test rejects them).
+//   - fixed row and column order per command; an absent value renders as "-".
+
+const BANNED = /[✓✗⚠⛔•∞—–]/; // checks/warn/stop/bullet/inf/em/en dash
+
+export function escapeCell(v) {
+  return String(v ?? '').replace(/\r?\n/g, ' ').replace(/(?<!\\)\|/g, '\\|').trim();
+}
+
+export function mdTable(headers, rows) {
+  const head = `| ${headers.join(' | ')} |`;
+  const sep = `| ${headers.map(() => '---').join(' | ')} |`;
+  const body = rows.map((r) => `| ${r.map(escapeCell).join(' | ')} |`);
+  return [head, sep, ...body].join('\n');
+}
+
+// Two-column "field/value" table. pairs: [[label, value], ...]; absent -> "-".
+export function fieldsTable(pairs) {
+  return mdTable(['항목', '값'], pairs.map(([k, v]) => [k, v === undefined || v === null || v === '' ? '-' : v]));
+}
+
+// title -> "# title"; fields -> 2-col table; sections -> "## title" + table|text;
+// notes -> trailing lines. Returns a string with no trailing newline (the CLI/print
+// layer appends one).
+export function dashboard({ title, fields = [], sections = [], notes = [] }) {
+  const parts = [`# ${title}`];
+  if (fields.length) parts.push('', fieldsTable(fields));
+  for (const s of sections) {
+    parts.push('', `## ${s.title}`);
+    if (s.table) parts.push('', mdTable(s.table.headers, s.table.rows));
+    else if (s.text) parts.push('', s.text);
+  }
+  for (const n of notes) parts.push('', n);
+  return parts.join('\n');
+}
+
+// Throw if a rendered block contains a banned glyph/dash; used by renderers in a
+// final guard and by the determinism test. Keeps the ASCII-table contract enforced.
+export function assertClean(text) {
+  const m = String(text).match(BANNED);
+  if (m) throw new Error(`render: banned character ${JSON.stringify(m[0])} in output`);
+  return text;
+}
+
+const yn = (v) => (v ? 'yes' : 'no');
+
+// ---- _compile (engine compile_desk payload) ----
+export function renderCompile(p) {
+  const fields = [
+    ['mode', p.mode],
+    ['작업 대기', p.queue?.pending_count ?? 0],
+    ['안전(safe)', p.queue?.safe_count ?? 0],
+    ['확인 필요', p.queue?.needs_confirmation_count ?? 0],
+    ['deep 후보', p.source_digest?.deep_compile_candidate_count ?? 0],
+    ['raw 읽기 허용', yn(p.performance_policy?.raw_full_reads_allowed)],
+    ['다음 행동', p.next_action],
+  ];
+  const sections = [];
+  if (p.candidates?.length) {
+    sections.push({
+      title: `후보 (우선순위) ${p.candidates.length}건`,
+      table: {
+        headers: ['순위', '우선순위', '후보', 'source id'],
+        rows: p.candidates.map((c) => [c.rank, c.priority, c.title || c.kind || '-', c.source_id || '-']),
+      },
+    });
+  }
+  const notes = [];
+  if (p.excluded?.length) notes.push(`제외(확인필요/비공개) ${p.excluded.length}건: ${p.excluded.map((e) => e.title || e.source_id).join(', ')}`);
+  if (p.candidates?.length) notes.push('몇 건 정리할까요? (숫자 1-10; "전부"는 안전한 것 최대 10건)');
+  else if (!p.selected_target && p.excluded?.length) notes.push('정리 가능한 안전 후보가 없습니다. 위 제외 항목은 확인/승인 후에만 처리됩니다.');
+  return assertClean(dashboard({ title: 'Neurain Compile', fields, sections, notes }));
+}
+
+// ---- _sync (engine sync payload) ----
+export function renderSync(p) {
+  if (!p.ok) return assertClean(`# Neurain Sync\n\n- ${p.error || p.reason}`);
+  const fields = [
+    ['세션', p.session_id],
+    ['mode', p.mode],
+    ['pulsed', yn(p.pulsed)],
+    ['작업 대기', p.queue?.pending_count ?? 0],
+    ['안전(safe)', p.queue?.safe_count ?? 0],
+    ['확인 필요', p.queue?.needs_review_count ?? 0],
+    ['충돌', p.queue?.conflict_count ?? 0],
+    ['durable wiki 쓰기', 'no'],
+    ['다음 권장', p.recommendation],
+  ];
+  return assertClean(dashboard({ title: 'Neurain Sync', fields }));
+}
+
+// ---- _save (engine capture_durable payload) ----
+export function renderSave(p) {
+  if (!p.ok) {
+    if (p.refused) {
+      const notes = [`secret 차단(blocked): ${p.reason}`, ...(p.hits || []).map((h) => `  [${h.confidence}] ${h.type}: ${h.sample}`)];
+      return assertClean(dashboard({ title: 'Neurain Capture - blocked', notes }));
+    }
+    return assertClean(`# Neurain Capture\n\n- ${p.error}`);
+  }
+  if (p.dry_run) {
+    const e = p.envelope;
+    const fields = [
+      ['source id', e.source_id],
+      ['raw 경로', e.raw_path],
+      ['영역', e.area_candidates?.join(', ') || 'none'],
+      ['민감도', e.sensitivity],
+      ['intent', e.write_intent],
+      ['확인 필요', yn(e.requires_user_decision)],
+    ];
+    if (p.duplicate_of) fields.push(['중복', `${p.duplicate_of.source_id} (${p.duplicate_of.raw_path})`]);
+    if (e.extracted_text_chars != null) fields.push(['추출 글자수', `${e.extracted_text_chars} (${e.extracted_method})`]);
+    if (e.overlap_candidates) fields.push(['overlap', e.overlap_candidates.map((o) => o.path).join(', ')]);
+    if (e.numeric_conflict_candidates) fields.push(['numeric 검토', `${e.numeric_conflict_candidates.length}건`]);
+    return assertClean(dashboard({ title: 'Neurain Capture (dry run)', fields }));
+  }
+  const fields = [
+    ['source id', p.source_id],
+    ['raw 경로', p.raw_path],
+  ];
+  if (p.asset_path) fields.push(['raw asset', p.asset_path]);
+  fields.push(['envelope', p.envelope_path], ['확인 필요', yn(p.requires_user_decision)]);
+  return assertClean(dashboard({ title: 'Neurain Captured', fields }));
+}
+
+// ---- _status (normalized view; both the engine status command and the vault
+// session-status tool build this view from their own payloads) ----
+// view = { mode: 'boot'|'all'|'session', ...fields, sections?, notes? }
+export function renderStatus(view) {
+  if (view.mode === 'all') {
+    return assertClean(dashboard({
+      title: 'Neurain Session Status',
+      fields: [['세션 수', view.session_count ?? 0]],
+      sections: view.sessions?.length
+        ? [{ title: '세션', table: { headers: ['세션', '상태', 'freshness', '작업 대기', 'handoff'], rows: view.sessions.map((s) => [s.session_id, s.status, s.freshness_status, s.pending_count, s.handoff_exists ? 'ok' : 'missing']) } }]
+        : [],
+    }));
+  }
+  if (view.mode === 'session') {
+    const fields = [
+      ['세션', view.session_id],
+      ['영역', view.area],
+      ['scope', view.scope],
+      ['작업 대기', view.pending_count ?? 0],
+      ['handoff', view.handoff_exists ? view.handoff_path : 'missing'],
+      ['area brief', view.area_brief_exists ? view.area_brief_path : 'missing'],
+      ['freshness', view.freshness_message],
+      ['다음 권장', view.next || '-'],
+    ];
+    return assertClean(dashboard({ title: 'Neurain Session Status', fields, notes: view.notes || [] }));
+  }
+  // boot
+  const fields = [
+    ['상태', view.state || 'ok'],
+    ['세션', view.session_count != null ? `${view.session_count}${view.fresh_count != null ? ` (fresh ${view.fresh_count} / stale ${view.stale_count})` : ''}` : '-'],
+    ['영역', view.areas?.length ? view.areas.join(', ') : '-'],
+    ['작업 대기', view.pending_text || (view.pending_count ? `${view.pending_count}` : '없음')],
+    ['지식화 후보', view.compile_candidate_count ?? 0],
+    ['정리 후보', view.tidy_candidate_count ?? 0],
+    ['구조 점검', view.structure_findings ?? 0],
+    ['지금 할 일', view.next || '-'],
+  ];
+  const notes = [...(view.notes || []), '자세한 점검: _status detail'];
+  return assertClean(dashboard({ title: 'Neurain Status', fields, notes }));
+}

package/src/core/status.mjs

@@ -13,6 +13,7 @@ import { vaultConfig } from './config.mjs';
 import { areaBriefPath, extractMarkdownSection, freshnessFor, loadSessionState, pendingQueueRows, readJsonl, readTextAt } from './vault_state.mjs';
 import { compileCandidateSummary } from './source_digest.mjs';
 import { computeDigest, renderDigest } from './digest.mjs';
+import { renderStatus } from './render.mjs';
 import { listLessons } from './lessons.mjs';
 
 function summarizeSession(root, vaultCfg, session, { staleDays, now }) {
@@ -108,28 +109,28 @@ export async function statusCommand(args) {
 
   if (!sessionId && !args.all) {
     const payload = bootStatus(root, vaultCfg, state, { staleDays, now });
+    payload.rendered = renderStatus({
+      mode: 'boot',
+      state: payload.ok ? 'ok' : '확인 필요',
+      session_count: payload.session_count,
+      areas: payload.active_areas,
+      pending_text: payload.total_pending_count
+        ? `${payload.total_pending_count}${payload.pending_requires_confirmation_count ? ` (승인 필요 ${payload.pending_requires_confirmation_count})` : ''}`
+        : '없음',
+      compile_candidate_count: payload.compile_candidate_count || 0,
+      next: payload.next_action,
+      notes: payload.stale_guidance ? [`참고: 오래된 세션 ${payload.stale_guidance.count}개는 오류가 아닙니다.`] : [],
+    });
     if (args.json) return { json: true, payload };
-    return {
-      text: [
-        '# Neurain Status',
-        '',
-        `- OK: ${payload.ok ? 'yes' : 'needs attention'}`,
-        `- Sessions: ${payload.session_count} | Areas: ${payload.active_areas.join(', ') || 'none'}`,
-        `- Pending: ${payload.total_pending_count}${payload.pending_requires_confirmation_count ? ` (confirmation needed: ${payload.pending_requires_confirmation_count})` : ''}`,
-        payload.compile_candidate_count ? `- Compile candidates: ${payload.compile_candidate_count}` : '',
-        payload.stale_guidance ? `- Stale sessions: ${payload.stale_guidance.count} (not an error)` : '',
-        `- Next: ${payload.next_action}`,
-      ].filter(Boolean).join('\n'),
-    };
+    return { text: payload.rendered };
   }
 
   if (args.all) {
     const sessions = Object.values(state.sessions || {}).map((s) => summarizeSession(root, vaultCfg, s, { staleDays, now }));
     const payload = { ok: true, command: 'status', durable_write: false, mode: 'all', updated_at: state.updated_at || '', count: sessions.length, sessions };
+    payload.rendered = renderStatus({ mode: 'all', session_count: payload.count, sessions });
     if (args.json) return { json: true, payload };
-    return {
-      text: ['# Session Status', '', `- Sessions: ${payload.count}`, ...sessions.map((s) => `- ${s.session_id}: ${s.status}, freshness ${s.freshness_status}, pending ${s.pending_count}, handoff ${s.handoff_exists ? 'ok' : 'missing'}`)].join('\n'),
-    };
+    return { text: payload.rendered };
   }
 
   const session = state.sessions[String(sessionId)];
@@ -158,18 +159,20 @@ export async function statusCommand(args) {
     lesson_review: lessonReview(root),
   };
   // The engine never acks; a vault shim acks after delivering the rendered text.
+  const digestBlock = renderDigest(sinceLastVisit);
+  payload.rendered = renderStatus({
+    mode: 'session',
+    session_id: payload.session_id,
+    area: payload.area,
+    scope: payload.scope,
+    pending_count: payload.pending_count,
+    handoff_exists: payload.handoff_exists,
+    handoff_path: payload.handoff_path,
+    area_brief_exists: payload.area_brief_exists,
+    area_brief_path: payload.area_brief_path,
+    freshness_message: payload.freshness_message,
+    notes: digestBlock ? [digestBlock] : [],
+  });
   if (args.json) return { json: true, payload };
-  return {
-    text: [
-      '# Session Status',
-      '',
-      `- Session: ${payload.session_id}`,
-      `- Area: ${payload.area}`,
-      `- Pending: ${payload.pending_count}`,
-      `- Handoff: ${payload.handoff_exists ? payload.handoff_path : 'missing'}`,
-      `- Area brief: ${payload.area_brief_exists ? payload.area_brief_path : 'missing'}`,
-      `- Freshness: ${payload.freshness_message}`,
-      renderDigest(sinceLastVisit) ? `\n${renderDigest(sinceLastVisit)}` : '',
-    ].filter(Boolean).join('\n'),
-  };
+  return { text: payload.rendered };
 }

package/src/core/sync.mjs

@@ -10,6 +10,7 @@ import { vaultConfig } from './config.mjs';
 import { areaBriefPath, loadSessionState, readJsonl } from './vault_state.mjs';
 import { slugify } from './envelope.mjs';
 import { pulseSession } from './session_write.mjs';
+import { renderSync } from './render.mjs';
 
 function readSummary(args, root) {
   if (typeof args.summary === 'string') return args.summary;
@@ -133,8 +134,7 @@ export async function syncCommand(args) {
 }
 
 function done(args, payload) {
+  payload.rendered = renderSync(payload);
   if (args.json) return { json: true, payload };
-  if (!payload.ok) return { text: `# Neurain Sync\n\n- ${payload.error || payload.reason}` };
-  const lines = ['# Neurain Sync', '', `- Session: ${payload.session_id}`, `- Mode: ${payload.mode}`, `- Pulsed: ${payload.pulsed ? 'yes' : 'no'}`, `- Pending: ${payload.queue.pending_count}`, `- Safe: ${payload.queue.safe_count}`, `- Needs review: ${payload.queue.needs_review_count}`, `- Conflicts: ${payload.queue.conflict_count}`, `- Durable wiki writes: no`, `- Recommendation: ${payload.recommendation}`];
-  return { text: lines.join('\n') };
+  return { text: payload.rendered };
 }

package/src/mcp/server.mjs

@@ -739,11 +739,11 @@ export async function startMcpServer(args) {
     }
     if (name === 'neurain_session_status') {
       const out = await statusCommand({ _: [scopedRoot(input.root, root)], 'session-id': input.sessionId, all: input.all, 'stale-days': input.staleDays, json: true });
-      return textResult(out.payload);
+      return renderedResult(out.payload);
     }
     if (name === 'neurain_digest_preview') {
       const out = await digestCommand({ _: [scopedRoot(input.root, root)], session: input.session, 'window-hours': input.windowHours, json: true });
-      return textResult(out.payload);
+      return renderedResult(out.payload);
     }
     if (name === 'neurain_queue_view') {
       const out = await queueCommand({ _: [scopedRoot(input.root, root)], queue: input.queue, status: input.status, pending: input.pending, stats: input.stats, 'lossless-check': input.losslessCheck, json: true });
@@ -771,7 +771,7 @@ export async function startMcpServer(args) {
     }
     if (name === 'neurain_compile') {
       const out = await compileCommand({ _: [scopedRoot(input.root, root)], target: input.target, 'session-id': input.sessionId, top: input.top, manifest: input.manifest, queue: input.queue, json: true });
-      return textResult(out.payload);
+      return renderedResult(out.payload);
     }
     throw new Error(`Unknown Neurain tool: ${name}`);
   });
@@ -837,6 +837,14 @@ function textResult(value) {
   };
 }
 
+// User-facing command views relay the engine's single rendered block (payload.rendered)
+// verbatim, so an MCP host shows the SAME markdown as the CLI. Falls back to JSON only
+// if a payload has no rendered block. Diagnostic/eval tools keep textResult (JSON).
+function renderedResult(payload) {
+  const text = payload?.rendered ?? JSON.stringify(payload, null, 2);
+  return { content: [{ type: 'text', text }] };
+}
+
 function answerEvalScaledCounts(total) {
   const count = Math.max(10, Math.min(Number(total || 120), 500));
   const supportedCases = Math.max(1, Math.round(count * 0.42));