neurain 0.1.0-alpha.0

package/src/core/link_check.mjs

@@ -0,0 +1,180 @@
+// `link-check` command (W-C, read-only). Validates every markdown link `[..](..)`
+// and wikilink `[[..]]` across the vault, reporting unresolved targets by file and
+// area. Writes nothing. Faithful port of the vault neurain-link-check tool; the
+// area buckets use the configured structural dirs (areas/wiki/system/raw) instead
+// of hardcoded prefixes, so no vault identifier enters the engine.
+import fs from 'node:fs';
+import path from 'node:path';
+import { absPath, readText, relPath, walkFiles } from './fs.mjs';
+import { vaultConfig } from './config.mjs';
+
+function reEsc(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export async function linkCheckCommand(args) {
+  const root = absPath(args._[0] || args.root || process.cwd());
+  const vaultCfg = vaultConfig(root);
+  const top = Number(args.top || 20);
+  const scope = String(args.scope || '.');
+  const includeRaw = Boolean(args['include-raw']);
+  const includeArchive = Boolean(args['include-archive']);
+  const includeOutput = Boolean(args['include-output']);
+
+  const rawPrefix = `${vaultCfg.raw_dir}/`;
+  const outPrefix = `${vaultCfg.output_dir}/`;
+  const isArchivePath = (rel) =>
+    rel.startsWith(`${vaultCfg.archive_dir}/`) || rel.startsWith('_trash/') || rel.includes('/_archive/') || rel.includes('/archive/');
+
+  const files = walkFiles(path.join(root, scope), { includeRaw: true, maxFiles: 200000 })
+    .filter((abs) => abs.endsWith('.md'))
+    .map((abs) => ({ abs, rel: relPath(root, abs) }))
+    .filter(({ rel }) => includeRaw || !rel.startsWith(rawPrefix))
+    .filter(({ rel }) => includeOutput || (!rel.startsWith(outPrefix) && !rel.startsWith('outputs/')))
+    .filter(({ rel }) => includeArchive || !isArchivePath(rel));
+
+  const basenameIndex = new Set(files.map(({ rel }) => path.basename(rel, '.md')));
+  const areaRe = new RegExp(`^${reEsc(vaultCfg.areas_dir)}/([^/]+)/`);
+
+  const brokenMarkdownLinks = [];
+  const unresolvedWikiLinks = [];
+  let markdownLinksChecked = 0;
+  let wikiLinksChecked = 0;
+
+  for (const { abs, rel } of files) {
+    const text = stripCode(readText(abs, ''));
+    for (const target of markdownTargets(text)) {
+      if (isExternalOrAnchor(target)) continue;
+      markdownLinksChecked += 1;
+      if (!targetExists(root, abs, target, basenameIndex)) brokenMarkdownLinks.push({ file: rel, target });
+    }
+    for (const target of wikiTargets(text)) {
+      if (isExternalOrAnchor(target)) continue;
+      wikiLinksChecked += 1;
+      if (!targetExists(root, abs, target, basenameIndex)) unresolvedWikiLinks.push({ file: rel, target });
+    }
+  }
+
+  const payload = {
+    ok: brokenMarkdownLinks.length === 0,
+    command: 'link-check',
+    durable_write: false,
+    scope,
+    include_raw: includeRaw,
+    include_archive: includeArchive,
+    include_output: includeOutput,
+    markdown_files: files.length,
+    markdown_links_checked: markdownLinksChecked,
+    broken_markdown_links_count: brokenMarkdownLinks.length,
+    broken_markdown_by_area: countByArea(brokenMarkdownLinks, areaRe, vaultCfg),
+    broken_markdown_top_files: countByFile(brokenMarkdownLinks).slice(0, top),
+    broken_markdown_sample: brokenMarkdownLinks.slice(0, top),
+    wiki_links_checked: wikiLinksChecked,
+    unresolved_wiki_links_count: unresolvedWikiLinks.length,
+    unresolved_wiki_by_area: countByArea(unresolvedWikiLinks, areaRe, vaultCfg),
+    unresolved_wiki_top_files: countByFile(unresolvedWikiLinks).slice(0, top),
+    unresolved_wiki_top_targets: countByTarget(unresolvedWikiLinks).slice(0, top),
+    unresolved_wiki_sample: unresolvedWikiLinks.slice(0, top),
+  };
+
+  if (args.json) return { json: true, payload };
+  return { text: render(payload) };
+}
+
+function markdownTargets(text) {
+  const targets = [];
+  const re = /(?<!!)!?\[[^\]]*\]\(([^)]+)\)/g;
+  let match;
+  while ((match = re.exec(text))) {
+    const raw = match[1].split(/\s+"/)[0].trim();
+    if (raw) targets.push(raw);
+  }
+  return targets;
+}
+
+function wikiTargets(text) {
+  const targets = [];
+  const re = /\[\[([^\]]+)\]\]/g;
+  let match;
+  while ((match = re.exec(text))) {
+    const raw = match[1].split('|')[0].trim();
+    if (raw) targets.push(raw);
+  }
+  return targets;
+}
+
+function stripCode(text) {
+  return String(text || '').replace(/```[\s\S]*?```/g, ' ').replace(/`[^`]*`/g, ' ');
+}
+
+function isExternalOrAnchor(rawTarget) {
+  const target = String(rawTarget || '').trim();
+  return !target || target.startsWith('#') || /^(https?:|mailto:|app:\/\/|obsidian:|data:)/i.test(target);
+}
+
+function targetExists(root, fromAbs, rawTarget, basenameIndex) {
+  let target = String(rawTarget || '').trim().replace(/^<|>$/g, '');
+  try { target = decodeURIComponent(target); } catch { /* keep original when not URI-encoded */ }
+  target = target.split('#')[0].trim();
+  if (!target) return true;
+
+  const candidates = [];
+  if (target.startsWith('/')) candidates.push(path.join(root, target.slice(1)));
+  candidates.push(path.resolve(path.dirname(fromAbs), target));
+  candidates.push(path.join(root, target));
+  if (!target.endsWith('.md')) {
+    candidates.push(path.resolve(path.dirname(fromAbs), `${target}.md`));
+    candidates.push(path.join(root, `${target}.md`));
+  }
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return true;
+  }
+  if (!target.includes('/') && basenameIndex.has(target)) return true;
+  return false;
+}
+
+function areaBucket(file, areaRe, vaultCfg) {
+  const m = String(file).match(areaRe);
+  if (m) return m[1];
+  if (file.startsWith(`${vaultCfg.wiki_dir}/`)) return vaultCfg.wiki_dir;
+  if (file.startsWith(`${vaultCfg.system_dir}/`)) return vaultCfg.system_dir;
+  if (file.startsWith(`${vaultCfg.raw_dir}/`)) return vaultCfg.raw_dir;
+  return file.split('/')[0] || '.';
+}
+
+function sortedCounts(counts) {
+  return [...counts.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+}
+
+function countByArea(items, areaRe, vaultCfg) {
+  const counts = new Map();
+  for (const item of items) {
+    const key = areaBucket(item.file, areaRe, vaultCfg);
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+  return sortedCounts(counts);
+}
+
+function countByFile(items) {
+  const counts = new Map();
+  for (const item of items) counts.set(item.file, (counts.get(item.file) || 0) + 1);
+  return sortedCounts(counts);
+}
+
+function countByTarget(items) {
+  const counts = new Map();
+  for (const item of items) counts.set(item.target, (counts.get(item.target) || 0) + 1);
+  return sortedCounts(counts);
+}
+
+function render(data) {
+  const lines = ['# Neurain Link Check', ''];
+  lines.push(`- OK: ${data.ok ? 'yes' : 'no'}`);
+  lines.push(`- Scope: ${data.scope}`);
+  lines.push(`- Markdown files: ${data.markdown_files}`);
+  lines.push(`- Strict Markdown links checked: ${data.markdown_links_checked}`);
+  lines.push(`- Broken strict Markdown links: ${data.broken_markdown_links_count}`);
+  lines.push(`- Wiki-style links checked: ${data.wiki_links_checked}`);
+  lines.push(`- Unresolved wiki-style links: ${data.unresolved_wiki_links_count}`);
+  return lines.join('\n');
+}

package/src/core/live_cases.mjs

@@ -0,0 +1,221 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { absPath, compactStamp, ensureDir, isTextFile, readText, relPath, safeResolve, sha256, walkFiles } from './fs.mjs';
+import { inferSensitivityFromPath, injectionLike, secretLike } from './safety.mjs';
+
+const DEFAULT_SAMPLE_SIZE = 12;
+const MAX_SAMPLE_SIZE = 50;
+
+export async function liveCasesCommand(args) {
+  const [subcommand, ...rest] = args._;
+  const root = absPath(rest[0] || args.root || process.cwd());
+  if (!subcommand || subcommand === 'scaffold') return renderLiveCaseScaffold(root, args);
+  throw new Error('Unknown live-cases command. Use "live-cases scaffold".');
+}
+
+export function buildLiveCaseScaffold(root, {
+  sampleSize = DEFAULT_SAMPLE_SIZE,
+  label = '',
+  output = '',
+  write = false,
+  confirm = '',
+} = {}) {
+  const limit = Math.max(1, Math.min(Number(sampleSize || DEFAULT_SAMPLE_SIZE), MAX_SAMPLE_SIZE));
+  const samples = collectSourceSamples(root, limit);
+  const payload = {
+    ok: true,
+    command: 'live-cases scaffold',
+    durable_write: false,
+    model_calls: false,
+    external_tool_calls: false,
+    e23_live_case_pack_scaffolded: true,
+    redacted_live_case_pack: true,
+    reviewed_live_user_evidence: false,
+    human_judged: false,
+    reviewer_required: true,
+    generated_at: compactStamp(),
+    folder_label: sanitizeLabel(label || 'reviewed-folder-001'),
+    folder_hash: sha256(absPath(root)).slice(0, 16),
+    sample_size: limit,
+    source_sample_count: samples.length,
+    source_samples: samples,
+    storage_safety: storageSafety(samples),
+    case_templates: buildCaseTemplates(samples),
+    next_steps: [
+      'A human reviewer must fill safe, non-private recall queries and expected terms before claiming reviewed live evidence.',
+      'Run recall eval, answer eval, and lessons eval with the filled local case files.',
+      'Store only the redacted case pack or aggregate eval receipts. Do not store raw private source text in product docs.',
+    ],
+  };
+  if (!write) return payload;
+  if (String(confirm || '') !== '1건 저장 진행') {
+    throw new Error('Writing a live case pack requires --confirm "1건 저장 진행".');
+  }
+  const rel = output
+    ? String(output).replace(/\\/g, '/')
+    : `output/live-cases/${compactStamp()}-e23-live-case-pack.json`;
+  if (path.isAbsolute(rel)) throw new Error('Live case pack --output must be a relative path inside the target root.');
+  const abs = safeResolve(root, rel);
+  ensureDir(path.dirname(abs));
+  const writtenPayload = {
+    ...payload,
+    durable_write: true,
+    output_path: rel,
+  };
+  fs.writeFileSync(abs, `${JSON.stringify(writtenPayload, null, 2)}\n`, 'utf8');
+  return writtenPayload;
+}
+
+function renderLiveCaseScaffold(root, args) {
+  const payload = buildLiveCaseScaffold(root, {
+    sampleSize: Number(args['sample-size'] || DEFAULT_SAMPLE_SIZE),
+    label: args.label || '',
+    output: args.output || '',
+    write: Boolean(args.write),
+    confirm: args.confirm || '',
+  });
+  if (args.json) return { json: true, payload };
+  return {
+    text: [
+      '# Neurain E23 live case scaffold',
+      '',
+      `- OK: ${payload.ok ? 'yes' : 'no'}`,
+      `- Sources sampled: ${payload.source_sample_count}`,
+      `- Reviewed live evidence: ${payload.reviewed_live_user_evidence ? 'yes' : 'no'}`,
+      `- Reviewer required: ${payload.reviewer_required ? 'yes' : 'no'}`,
+      `- Durable write: ${payload.durable_write ? 'yes' : 'no'}`,
+      payload.output_path ? `- Output: ${payload.output_path}` : '',
+    ].filter(Boolean).join('\n'),
+  };
+}
+
+function collectSourceSamples(root, limit) {
+  const out = [];
+  for (const file of walkFiles(root, { includeRaw: false, maxFiles: 50000 })) {
+    if (out.length >= limit) break;
+    const rel = relPath(root, file);
+    if (!isTextFile(file)) continue;
+    if (!isLiveCaseSourcePath(rel)) continue;
+    const text = readText(file, '');
+    const flags = unsafeFlags(rel, text);
+    out.push({
+      source_ref: `source-${String(out.length + 1).padStart(3, '0')}`,
+      kind: kindForPath(rel),
+      path_hash: sha256(rel).slice(0, 16),
+      content_hash: sha256(text).slice(0, 16),
+      sensitivity: flags.private_path ? 'private' : 'internal',
+      redacted: flags.private_path || flags.secret_like || flags.injection_like,
+      unsafe_flags: flags,
+      raw_text_stored: false,
+      absolute_path_stored: false,
+      reviewer_note: 'Use this source only to create local reviewed cases. Do not copy private source text into product docs.',
+    });
+  }
+  return out;
+}
+
+function isLiveCaseSourcePath(rel) {
+  if (/^raw\//.test(rel)) return false;
+  if (/^output\/receipts\//.test(rel)) return false;
+  if (/^output\/live-cases\//.test(rel)) return false;
+  if (/^node_modules\//.test(rel)) return false;
+  return [
+    /^README\.md$/,
+    /^index\.md$/,
+    /^wiki\//,
+    /^00_system\/sessions\/handoffs\/.+\.md$/,
+    /^10_areas\/[^/]+\/current\/.+\.md$/,
+    /^10_areas\/[^/]+\/product\/.+\.md$/,
+    /^10_areas\/[^/]+\/log\.md$/,
+    /^docs\/.+\.md$/,
+  ].some((pattern) => pattern.test(rel));
+}
+
+function kindForPath(rel) {
+  if (rel.startsWith('docs/')) return 'docs';
+  if (rel.startsWith('wiki/')) return 'wiki';
+  if (rel.includes('/current/')) return 'current';
+  if (rel.includes('/product/')) return 'product';
+  if (rel.includes('/sessions/handoffs/')) return 'session';
+  if (rel.endsWith('log.md')) return 'log';
+  return 'markdown';
+}
+
+function unsafeFlags(rel, text) {
+  return {
+    private_path: inferSensitivityFromPath(rel) === 'private',
+    secret_like: Boolean(secretLike(text)),
+    injection_like: Boolean(injectionLike(text)),
+  };
+}
+
+function storageSafety(samples) {
+  return {
+    raw_source_text_stored: false,
+    absolute_paths_stored: false,
+    private_paths_stored: false,
+    secret_like_content_stored: false,
+    instruction_injection_content_stored: false,
+    redacted_source_count: samples.filter((item) => item.redacted).length,
+    hash_only_source_refs: true,
+  };
+}
+
+function buildCaseTemplates(samples) {
+  const refs = samples.slice(0, 3).map((sample) => sample.source_ref);
+  return {
+    recall_cases_template: refs.map((sourceRef, index) => ({
+      id: `reviewed-live-recall-${String(index + 1).padStart(3, '0')}`,
+      source_ref: sourceRef,
+      status: 'needs-human-review',
+      query: '<fill safe non-private query locally>',
+      host: '',
+      expected_path_contains: ['<fill non-private path marker or event id locally>'],
+      expected_terms: ['<fill safe support term locally>'],
+      wrong_hosts: [],
+      forbidden_path_contains: ['private', 'secret', 'credential', 'token'],
+    })),
+    answer_cases_template: [
+      {
+        id: 'reviewed-live-answer-supported-001',
+        type: 'supported',
+        status: 'needs-human-review',
+        sources: [{ id: 's1', source_ref: refs[0] || '', text: '<fill safe source excerpt locally>' }],
+        claims: [{ text: '<fill supported claim>', support_terms: ['<safe term>'], citations: ['s1'] }],
+        answer: { text: '<fill answer>', citations: [{ source_id: 's1', support_terms: ['<safe term>'] }] },
+      },
+      {
+        id: 'reviewed-live-answer-no-answer-001',
+        type: 'no_answer',
+        status: 'needs-human-review',
+        sources: [{ id: 's1', source_ref: refs[1] || '', text: '<fill safe nearby source excerpt locally>' }],
+        claims: [],
+        answer: { text: 'Not enough evidence in the provided sources.', abstained: true, citations: [] },
+      },
+    ],
+    lesson_cases_template: [
+      {
+        id: 'reviewed-live-lesson-positive-001',
+        type: 'positive',
+        status: 'needs-human-review',
+        source_ref: refs[0] || '',
+        text: '<fill safe lesson candidate text locally>',
+      },
+      {
+        id: 'reviewed-live-lesson-negative-001',
+        type: 'negative',
+        status: 'needs-human-review',
+        source_ref: refs[1] || '',
+        text: '<fill ordinary note that should not become a lesson locally>',
+      },
+    ],
+  };
+}
+
+function sanitizeLabel(value) {
+  return String(value || '')
+    .replace(/[^a-zA-Z0-9._ -]+/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 80) || 'reviewed-folder-001';
+}

package/src/core/onboard.mjs

@@ -0,0 +1,175 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { scanAdoption } from './adopt.mjs';
+import { absPath, exists, safeResolve } from './fs.mjs';
+
+export async function onboardCommand(args) {
+  const root = absPath(args._[0] || args.folder || process.cwd());
+  const lang = args.lang === 'en' ? 'en' : 'ko';
+  const host = normalizeHost(args.host || 'codex');
+  const profile = buildOnboardingProfile(root, { lang, host });
+  if (args.json) return { json: true, payload: profile };
+  return { text: renderOnboarding(profile) };
+}
+
+export function buildOnboardingProfile(root, { lang = 'ko', host = 'codex' } = {}) {
+  const folderExists = exists(root);
+  const isDirectory = folderExists && fs.statSync(root).isDirectory();
+  const initialized = isDirectory && exists(safeResolve(root, 'neurain.config.json'));
+  const areaCount = initialized ? countAreaFolders(root) : 0;
+  const adoption = isDirectory && !initialized ? safeAdoptionSummary(root) : null;
+  const connectCommand = host === 'gemini'
+    ? `npx neurain connect gemini "${root}" --dry-run`
+    : host === 'runtime'
+      ? `npx neurain connect runtime "${root}" --dry-run`
+      : `npx neurain connect ${host} "${root}" --dry-run`;
+
+  const steps = nextSteps({ root, lang, host, folderExists, isDirectory, initialized, adoption, connectCommand });
+  return {
+    ok: folderExists ? isDirectory : true,
+    command: 'onboard',
+    generated_for: 'non_developer_first_run',
+    durable_write: false,
+    model_call: false,
+    external_call: false,
+    root,
+    lang,
+    host,
+    folder_exists: folderExists,
+    initialized,
+    area_count: areaCount,
+    adoption_scan_summary: adoption,
+    recommended_next_command: steps[0]?.command || '',
+    steps,
+    what_neurain_stores: [
+      'A local vault structure for sources, wiki, areas, sessions, and receipts.',
+      'Only files or receipts created through explicit CLI actions.',
+      'Redacted eval scaffolds that avoid raw source text when requested.',
+    ],
+    what_neurain_does_not_store: [
+      'Cloud memory by default.',
+      'Prompt bodies, transcript paths, tool stdout, or tool stderr in lifecycle receipts.',
+      'Existing work-folder adapter files until adoption is explicitly confirmed.',
+    ],
+  };
+}
+
+function nextSteps({ root, lang, host, folderExists, isDirectory, initialized, adoption, connectCommand }) {
+  if (!folderExists) {
+    return [
+      {
+        title: text(lang, 'Create a local Neurain vault', '로컬 Neurain vault 만들기'),
+        why: text(lang, 'This creates the starter folders and rules in a new local folder.', '새 로컬 폴더에 시작 폴더와 기본 규칙을 만듭니다.'),
+        command: `npx neurain init "${root}" --lang ${lang}`,
+      },
+    ];
+  }
+  if (!isDirectory) {
+    return [
+      {
+        title: text(lang, 'Choose a folder', '폴더 선택하기'),
+        why: text(lang, 'Neurain starts from a folder, not a single file.', 'Neurain은 단일 파일이 아니라 폴더에서 시작합니다.'),
+        command: 'npx neurain onboard <folder>',
+      },
+    ];
+  }
+  if (!initialized) {
+    const mode = adoption?.recommended_mode || 'copy';
+    return [
+      {
+        title: text(lang, 'Scan before connecting', '연결 전에 먼저 스캔하기'),
+        why: text(lang, `This reads the folder and recommends ${mode} mode before any write.`, `쓰기 전에 폴더를 읽기 전용으로 확인하고 ${mode} 모드를 추천합니다.`),
+        command: `npx neurain adopt "${root}" --dry-run`,
+      },
+      {
+        title: text(lang, 'Create a clean starter vault if this is a new Neurain folder', '새 Neurain 폴더라면 starter vault 만들기'),
+        why: text(lang, 'Use this only when the target should become a Neurain vault.', '대상 폴더 자체를 Neurain vault로 만들 때만 사용합니다.'),
+        command: `npx neurain init "${root}" --lang ${lang}`,
+      },
+    ];
+  }
+  return [
+    {
+      title: text(lang, 'Check health', '상태 확인'),
+      why: text(lang, 'This confirms the local vault is readable and ready.', '로컬 vault가 읽히고 준비되었는지 확인합니다.'),
+      command: `npx neurain doctor "${root}"`,
+    },
+    {
+      title: text(lang, `Preview ${host} connection`, `${host} 연결 미리보기`),
+      why: text(lang, 'Dry-run prints the host connection command without changing host config.', 'dry-run은 host 설정을 바꾸지 않고 연결 방법만 보여줍니다.'),
+      command: connectCommand,
+    },
+    {
+      title: text(lang, 'Preview the working loop', '작업 루프 미리보기'),
+      why: text(lang, 'Wrap preview shows what future sessions can remember without writing durable knowledge.', 'wrap 미리보기는 durable knowledge를 쓰지 않고 다음 세션이 이어받을 내용을 보여줍니다.'),
+      command: `npx neurain wrap "${root}" --dry-run`,
+    },
+  ];
+}
+
+function safeAdoptionSummary(root) {
+  try {
+    const scan = scanAdoption(root, { dryRun: true });
+    return {
+      scanned_files: scan.summary.scanned_files,
+      excluded_entries: scan.summary.excluded_entries,
+      private_or_secret_files: scan.summary.private_or_secret_files,
+      risk_count: scan.summary.risk_count,
+      recommended_mode: scan.summary.recommended_mode,
+      write_required_before_apply: false,
+    };
+  } catch (error) {
+    return {
+      scanned_files: 0,
+      excluded_entries: 0,
+      private_or_secret_files: 0,
+      risk_count: 1,
+      recommended_mode: 'copy',
+      write_required_before_apply: false,
+      scan_error: error.message || String(error),
+    };
+  }
+}
+
+function countAreaFolders(root) {
+  try {
+    const areasRoot = safeResolve(root, '10_areas');
+    if (!exists(areasRoot)) return 0;
+    return fs.readdirSync(areasRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length;
+  } catch {
+    return 0;
+  }
+}
+
+function renderOnboarding(profile) {
+  const lines = [
+    '# Neurain onboarding',
+    '',
+    `- Folder: ${profile.root}`,
+    `- Ready: ${profile.initialized ? 'yes' : 'not yet'}`,
+    `- Writes made: no`,
+  ];
+  if (profile.adoption_scan_summary) {
+    lines.push(
+      `- Recommended adoption mode: ${profile.adoption_scan_summary.recommended_mode}`,
+      `- Risks found: ${profile.adoption_scan_summary.risk_count}`,
+    );
+  }
+  lines.push('', 'Next steps:');
+  for (const [index, step] of profile.steps.entries()) {
+    lines.push('', `${index + 1}. ${step.title}`, `   ${step.why}`, `   ${step.command}`);
+  }
+  lines.push('', 'Stores:', ...profile.what_neurain_stores.map((item) => `- ${item}`));
+  lines.push('', 'Does not store:', ...profile.what_neurain_does_not_store.map((item) => `- ${item}`));
+  return lines.join('\n');
+}
+
+function normalizeHost(value) {
+  const host = String(value || 'codex').toLowerCase();
+  if (['codex', 'claude', 'gemini', 'runtime'].includes(host)) return host;
+  return 'codex';
+}
+
+function text(lang, en, ko) {
+  return lang === 'en' ? en : ko;
+}