elanous 0.2.14 → 0.2.16

package/src/cli/doctor-cli.ts

@@ -39,6 +39,7 @@ import { formatDoctorLocalLlm, probeDoctorLocalLlm, type DoctorLocalLlm } from '
 import type { LlmInventory } from '../llm/local-manager/types.js';
 import { buildDoctorBundle } from './doctor-bundle.js';
 import { uploadDoctorBundle } from './doctor-bundle-upload.js';
+import { checkNodeModules, formatNodeModulesCheck, nodeModulesTrees } from './doctor-node-modules.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -1216,9 +1217,30 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
   const out = deps.out ?? { log: (value: string) => console.log(value) };
   const err = deps.err ?? { error: (value: string) => console.error(value) };
   const setExitCode = deps.setExitCode ?? ((code: number) => { process.exitCode = code; });
-  program.command('doctor')
+  const doctor = program.command('doctor')
     .description('Reports whether credentials resolve and where each resolution comes from')
+    .option('--json', 'structured output');
+  doctor.command('node-modules')
+    .description('Check installed top-level packages against bun.lock (read-only)')
+    .option('--dir <tree>', 'tree to check', process.cwd())
+    .option('--all', 'also check nested package.json trees')
     .option('--json', 'structured output')
+    .action((opts: { dir: string; all?: boolean; json?: boolean }, command: Command) => {
+      const json = opts.json || command.parent?.opts().json === true;
+      let dirs: string[];
+      try { dirs = opts.all ? nodeModulesTrees(opts.dir) : [resolve(opts.dir)]; }
+      catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        if (json) out.log(JSON.stringify({ status: 'unreadable', reason }));
+        else out.log(`unreadable: ${reason}`);
+        setExitCode(1);
+        return;
+      }
+      const checks = dirs.map(checkNodeModules);
+      out.log(json ? JSON.stringify(opts.all ? checks : checks[0], null, 2) : checks.map(formatNodeModulesCheck).join('\n'));
+      if (checks.some((check) => check.status !== 'ok')) setExitCode(1);
+    });
+  doctor
     .option('--credentials', 'show per-credential details in human-readable output')
     .option('--bundle', 'write a redacted diagnostics archive for support')
     .option('--upload', 'send the bundle to diagnostics.uploadUrl after consent (requires --bundle)')

package/src/cli/doctor-node-modules.ts

@@ -0,0 +1,147 @@
+import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export interface NodeModulesCheck {
+  dir: string;
+  status: 'ok' | 'issues' | 'unreadable';
+  missing: string[];
+  mismatch: { name: string; expected: string; actual: string }[];
+  borrowed: { target: string; tree: string } | null;
+  reason?: string;
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function loadJson(path: string): unknown {
+  return JSON.parse(readFileSync(path, 'utf8')) as unknown;
+}
+
+function dependencyNames(pkg: Record<string, unknown>): string[] {
+  if (!record(pkg.dependencies ?? {}) || !record(pkg.devDependencies ?? {})) throw new Error('invalid package.json dependencies');
+  return [...new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})])].sort();
+}
+
+interface LockContext { lockRoot: string; workspace: Record<string, unknown>; packages: Record<string, unknown>; scope: string | null }
+
+/** Own bun.lock first; otherwise the nearest ancestor bun.lock whose workspaces list this folder (root-lock Bun workspaces). */
+function findLock(root: string, packageName: string | null): LockContext {
+  let current = root;
+  for (;;) {
+    let text: string | null = null;
+    try { text = readFileSync(join(current, 'bun.lock'), 'utf8'); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+    if (text !== null) {
+      const lock = Bun.JSONC.parse(text) as unknown;
+      if (!record(lock) || !record(lock.packages) || !record(lock.workspaces)) throw new Error('invalid bun.lock');
+      const key = relative(current, root).split(sep).join('/');
+      const workspace = lock.workspaces[key];
+      if (record(workspace)) return { lockRoot: current, workspace, packages: lock.packages, scope: key === '' ? null : (packageName ?? key) };
+      if (key === '') throw new Error('invalid bun.lock');
+      throw new Error(`bun.lock at ${current} does not list workspace ${key}`);
+    }
+    const parent = dirname(current);
+    if (parent === current) throw new Error('no bun.lock in this folder or any parent workspace root');
+    current = parent;
+  }
+}
+
+function lockedVersion(packages: Record<string, unknown>, name: string, scope: string | null = null): string {
+  // Bun keys a workspace-specific resolution as «<workspace>/<dep>» when it differs from the hoisted one.
+  const scoped = scope ? packages[`${scope}/${name}`] : undefined;
+  const entry = Array.isArray(scoped) ? scoped : packages[name];
+  if (!Array.isArray(entry) || typeof entry[0] !== 'string' || !entry[0].startsWith(`${name}@`) || entry[0].length <= name.length + 1) {
+    throw new Error(`bun.lock has no resolved version for ${name}`);
+  }
+  return entry[0].slice(name.length + 1);
+}
+
+export function checkNodeModules(dir: string): NodeModulesCheck {
+  const root = resolve(dir);
+  const result: NodeModulesCheck = { dir: root, status: 'ok', missing: [], mismatch: [], borrowed: null };
+  try {
+    const pkg = loadJson(join(root, 'package.json'));
+    if (!record(pkg)) throw new Error('invalid package.json');
+    const names = dependencyNames(pkg);
+    const lock = findLock(root, typeof pkg.name === 'string' ? pkg.name : null);
+    const declared = dependencyNames(lock.workspace);
+    for (const name of names) {
+      if (!declared.includes(name)) throw new Error(`bun.lock does not declare ${name}`);
+    }
+    const versions = new Map(names.map((name) => [name, lockedVersion(lock.packages, name, lock.scope)]));
+    // A workspace without its own node_modules resolves hoisted packages from the lock root.
+    const own = join(root, 'node_modules');
+    const modules = lock.lockRoot !== root && !lstatSync(own, { throwIfNoEntry: false }) ? join(lock.lockRoot, 'node_modules') : own;
+    try {
+      const entry = lstatSync(modules);
+      if (entry.isSymbolicLink()) {
+        const target = realpathSync(modules);
+        if (!lstatSync(target).isDirectory()) throw new Error('node_modules symlink target is not a directory');
+        result.borrowed = { target, tree: dirname(target) };
+      } else if (!entry.isDirectory()) {
+        throw new Error('node_modules is not a directory');
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      // A dangling symlink has a different cause from an absent node_modules directory.
+      if (lstatSync(modules, { throwIfNoEntry: false })?.isSymbolicLink()) throw new Error('node_modules symlink target is missing');
+      result.missing.push(...names);
+      if (names.length) result.status = 'issues';
+      return result;
+    }
+    for (const name of names) {
+      let installed: unknown;
+      const candidates = [...new Set([modules, join(lock.lockRoot, 'node_modules')])];
+      for (const base of candidates) {
+        try {
+          installed = loadJson(join(base, name, 'package.json'));
+          break;
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+        }
+      }
+      if (installed === undefined) {
+        result.missing.push(name);
+        continue;
+      }
+      if (!record(installed) || typeof installed.version !== 'string') throw new Error(`invalid node_modules/${name}/package.json`);
+      const expected = versions.get(name)!;
+      if (installed.version !== expected) result.mismatch.push({ name, expected, actual: installed.version });
+    }
+    if (result.missing.length || result.mismatch.length) result.status = 'issues';
+  } catch (error) {
+    result.status = 'unreadable';
+    result.reason = error instanceof Error ? error.message : String(error);
+  } finally {
+    debug.log('doctor.node-modules', 'checked', { dir: root, missing: result.missing, mismatch: result.mismatch, borrowed: result.borrowed });
+  }
+  return result;
+}
+
+export function nodeModulesTrees(dir: string): string[] {
+  const root = resolve(dir);
+  const found = [root];
+  const skip = new Set(['node_modules', '.git', '.next', 'dist', 'build', 'out', '.elanous-test']);
+  function visit(current: string): void {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      if (!entry.isDirectory() || skip.has(entry.name) || entry.name.startsWith('.')) continue;
+      const child = join(current, entry.name);
+      const children = readdirSync(child);
+      if (children.includes('package.json')) found.push(child);
+      visit(child);
+    }
+  }
+  visit(root);
+  return found;
+}
+
+export function formatNodeModulesCheck(result: NodeModulesCheck): string {
+  const lines = [`${result.dir}: ${result.status === 'ok' ? '정상' : result.status === 'unreadable' ? '못 읽음' : '결손'}`];
+  if (result.borrowed) lines.push(`  빌린 트리: ${result.borrowed.tree} (node_modules → ${result.borrowed.target})`);
+  if (result.missing.length) lines.push(`  빠짐 ${result.missing.length}: ${result.missing.join(', ')}`);
+  if (result.mismatch.length) lines.push(`  버전 다름 ${result.mismatch.length}: ${result.mismatch.map(({ name, expected, actual }) => `${name} (${actual} != ${expected})`).join(', ')}`);
+  if (result.reason) lines.push(`  이유: ${result.reason}`);
+  return lines.join('\n');
+}

package/src/cli/intake-cli.ts

@@ -21,6 +21,13 @@ export interface IntakeToTasksCliDeps {
   llm?: (input: IntakeTaskInput) => Promise<string>;
 }
 
+export interface IntakeDigestCliDeps {
+  root?: string;
+  annotateLens?: (root: string, day: string) => Promise<unknown>;
+  buildDigest?: typeof import('../intake-plane/digest.js').buildIntakeDigest;
+  sendTelegram?: (text: string) => Promise<boolean>;
+}
+
 export function intakeToTasksMessages(content: string) {
   return [
     { role: 'system' as const, content: 'Interpret the supplied goal line or idea note into up to three actionable tasks. Respond only with JSON: {"tasks":[{"type":"implement|research|document|operate","title":"...","description":"...","priority":"low|medium|high","acceptanceCriteria":["..."]}],"questions":["..."]}. Each task needs a verifiable acceptance criterion; put unresolved requests in questions instead. Do not invent facts. Limit each title to 80 characters and description to 4000 characters.' },
@@ -76,6 +83,44 @@ export async function runIntakeToTasksCli(
   return runIntakeToTasks(deps.root, opts, { llm, post });
 }
 
+/** `--telegram` 다이제스트. 렌즈는 digest 를 만들기 전에 돈다. 렌즈 실패는 보고를 막지 않는다. */
+export async function runIntakeDigestCli(
+  opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string },
+  deps: IntakeDigestCliDeps = {},
+): Promise<{ sent?: boolean; empty?: boolean }> {
+  const { buildIntakeDigest, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
+  const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+  const root = deps.root ?? effectiveInstanceRoot();
+  const day = opts.day ?? new Date(Date.now() + 9 * 3600_000).toISOString().slice(0, 10);
+  if (opts.telegram) {
+    const annotate = deps.annotateLens ?? (async (lensRoot, lensDay) => {
+      const { annotateIntakeLens } = await import('../intake-plane/lens.js');
+      return annotateIntakeLens(lensRoot, lensDay);
+    });
+    try { await annotate(root, day); }
+    catch (error) { debug.log('intake.lens', 'annotate-failed', { day, reason: error instanceof Error ? error.message : String(error) }); }
+  }
+  const d = (deps.buildDigest ?? buildIntakeDigest)(root, day);
+  if (opts.telegram) {
+    if (!d.absorbed.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
+    const text = renderDigestTelegram(d, { ...(opts.vault ? { vaultRoot: opts.vault } : {}), ...(opts.note ? { notePath: opts.note } : {}) });
+    const sent = deps.sendTelegram
+      ? await deps.sendTelegram(text)
+      : await (async () => {
+        const { sendTelegramReport } = await import('../telegram-report.js');
+        const { getUserConfig } = await import('../user-config.js');
+        return sendTelegramReport(getUserConfig(), text, { markdown: true, kind: 'intake' });
+      })();
+    debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length, sent });
+    console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');
+    if (!sent) process.exitCode = 3;
+    return { sent };
+  }
+  if (opts.json) { await writeStdoutFully(JSON.stringify(d, null, 2)); return {}; }
+  await writeStdoutFully(renderDigestMarkdown(d));
+  return {};
+}
+
 export function resolveIntakeCheckRoot(
   cwd: string,
   git: typeof runGitCommand = runGitCommand,
@@ -283,23 +328,7 @@ export function registerIntakeCommands(program: Command): void {
     .option('--vault <root>', '옵시디언 볼트 뿌리 — 텔레그램 판에 노트 열기 주소를 싣는다')
     .option('--note <path>', '열기 주소가 가리킬 노트(그날 트렌드 노트)')
     .action(async (opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string }) => {
-      const { buildIntakeDigest, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
-      const { effectiveInstanceRoot } = await import('../instance/resolve.js');
-      const day = opts.day ?? new Date(Date.now() + 9 * 3600_000).toISOString().slice(0, 10);
-      const d = buildIntakeDigest(effectiveInstanceRoot(), day);
-      if (opts.telegram) {
-        if (!d.absorbed.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return; }
-        const { sendTelegramReport } = await import('../telegram-report.js');
-        const { getUserConfig } = await import('../user-config.js');
-        const text = renderDigestTelegram(d, { ...(opts.vault ? { vaultRoot: opts.vault } : {}), ...(opts.note ? { notePath: opts.note } : {}) });
-        const sent = await sendTelegramReport(getUserConfig(), text, { markdown: true, kind: 'intake' });
-        debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length, sent });
-        console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');
-        if (!sent) process.exitCode = 3;
-        return;
-      }
-      if (opts.json) { await writeStdoutFully(JSON.stringify(d, null, 2)); return; }
-      await writeStdoutFully(renderDigestMarkdown(d));
+      await runIntakeDigestCli(opts);
     });
 
   intakeCmd

package/src/cli/know-cli.ts

@@ -0,0 +1,20 @@
+import type { Command } from 'commander';
+import { knowFind, type KnowFindDeps } from '../knowledge/know-find.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+export function registerKnowCommand(program: Command, deps: Partial<KnowFindDeps> = {}, out: Pick<Console, 'log' | 'error'> = console): void {
+  program.command('know <words...>').description('대표 지시 · 결정 · 판 칸 · 교훈을 한 질문으로 검색')
+    .option('--json', 'JSON 출력').option('--limit <N>', '최대 결과 수', '20')
+    .action(async (words: string[], opts: { json?: boolean; limit: string }) => {
+      const limit = Number(opts.limit);
+      if (!Number.isSafeInteger(limit) || limit < 1) throw new Error('--limit must be a positive integer');
+      const result = knowFind(words.join(' '), deps);
+      const rows = result.rows.slice(0, limit);
+      if (opts.json) {
+        await writeStdoutJson(JSON.stringify({ rows, unavailable: result.unavailable }) + '\n');
+        return;
+      }
+      for (const row of rows) out.log(`[${row.source}] ${row.id} · ${row.title} · ${row.status}${row.current ? ' · (지금 유효)' : ''}`);
+      for (const item of result.unavailable) out.error(`[${item.source}] 못 읽음 · ${item.reason}`);
+    });
+}

package/src/cli/logs-cli.ts

@@ -715,7 +715,7 @@ export function podObservationGapNotice(
     .some((prefix) => category.startsWith(prefix));
   const categories = [...(query.categories ?? []), ...(query.exactCategories ?? [])];
   if (!categories.some(childCategory) && !(categories.length === 0 && (query.events?.length ?? 0) > 0)) return null;
-  return `안내: 이 창에 Pod 에서 돈 런 ${podRuns}개 — Pod 자식의 관측은 이 logs.db 에 수집되지 않는다(POD-OBS). 원장으로 본다: elanous self run-ledger <runId>`;
+  return `안내: 이 창에 Pod 에서 돈 런 ${podRuns}개 — Pod 자식의 관측은 «발사한 트리의 파생 우주» logs.db 로 회수된다(POD-OBS) — 전체: elanous logs --all --include-test · 런 하나: elanous self run-ledger <runId>`;
 }
 
 /** Select ledger roots independently of DB existence; --all includes registered roots with no logs.db. */
@@ -1038,6 +1038,24 @@ export function otherInstanceHint(matches: readonly { name: string; count: numbe
   return `  ↳ 다른 인스턴스에는 있다 — ${found}\n    전체를 보려면: elanous logs --all --include-test${filters ? ` ${filters}` : ''}`;
 }
 
+/** POD-OBS(10-06): 결과가 «0이 아닌데 적을 때»도 조용하지 않게 — 다른 우주에 더 많으면 경고한다.
+ *  실측: 24h `pre-pr-sync` 운영 1건 vs 발사 트리 파생 우주 276건(Pod 자식 재방출은 부모 하니스의 우주에 쌓인다). */
+export function otherInstanceMajorityWarning(
+  shown: number,
+  matches: readonly { name: string; count: number }[],
+  opts: LogsCliOpts,
+): string | null {
+  const elsewhere = matches.reduce((sum, match) => sum + match.count, 0);
+  if (shown <= 0 || elsewhere <= shown) return null;
+  const top = [...matches].sort((a, b) => b.count - a.count);
+  const named = top.slice(0, 3).map((match) => `${match.name} ${match.count}건`).join(' · ');
+  const more = top.length > 3 ? ` 외 ${top.length - 3}곳` : '';
+  const filters = requeryFilterArgs(opts);
+  return `⚠ 여기 ${shown}건 · 다른 우주에 ${elsewhere}건이 더 있다 — ${named}${more}\n`
+    + '    (Pod 자식 관측은 발사한 트리의 파생 우주에 쌓인다 · 이 수만 보고 «적다»로 읽지 말 것)\n'
+    + `    전체를 보려면: elanous logs --all --include-test${filters ? ` ${filters}` : ''}`;
+}
+
 export function buildQuery(opts: LogsCliOpts): { query: LogQuery; error?: string } {
   const q: LogQuery = {};
   if (opts.level) {
@@ -1789,6 +1807,30 @@ export async function runLogsCli(opts: LogsCliOpts, deps: RunLogsCliDeps = {}):
       }
       const coverageHint = runCoverageHint(out.map(({ row }) => row));
       if (coverageHint) console.error(coverageHint);
+      // 좁힌 조회(이벤트·카테고리)만 — 넓은 조회까지 매번 전 우주를 열지 않는다.
+      if (out.length > 0 && ((query.events?.length ?? 0) > 0 || (query.categories?.length ?? 0) > 0
+        || (query.exactCategories?.length ?? 0) > 0)) {
+        const matches = probeOtherInstanceMatches(opts, query, resolved.targets.map((target) => target.dbPath));
+        // 표시 상한(--limit)이 아니라 «여기» 실제 일치 수와 비교한다(상한 100 을 «100건»으로 말하지 않는다).
+        let here: number | null = null;
+        try {
+          here = Math.max(out.length, (deps.countMatching ?? ((candidate: LogQuery) => opened.reduce(
+            (count, { store }) => count + store.countMatching(candidate), 0)))(query));
+        } catch (error) {
+          // 셈을 못 했으면 경고하지 않는다 — 잘린 표시 수를 «여기 N건»으로 말하지 않는다.
+          debug.log('logs.cli', 'other-instance-count-failed', { shown: out.length, error: error instanceof Error ? error.message : String(error) });
+        }
+        const majority = here === null ? null : otherInstanceMajorityWarning(here, matches, opts);
+        if (majority) {
+          console.error(majority);
+          debug.log('logs.cli', 'other-instance-majority', {
+            shown: out.length,
+            here,
+            elsewhere: matches.reduce((sum, match) => sum + match.count, 0),
+            instances: matches.length,
+          });
+        }
+      }
       if (out.length === 0) {
         console.error('(일치하는 로그 없음)');
         const instanceHint = otherInstanceHint(

package/src/cli/pod-cli.ts

@@ -94,6 +94,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
             const mem = (v: number | null) => v === null ? '?' : `${(v / 1024 ** 3).toFixed(1)}Gi`;
             io.log(`${m.context} | ${m.capacity} | ${m.running ?? '?'} | ${m.pending ?? '?'} | ${mem(m.memoryLimitBytes)}/${mem(m.allocatableMemoryBytes)} | ${m.allocatableCpuMillicores === null ? '?' : m.allocatableCpuMillicores / 1000}${m.reason ? ` (${m.reason})` : ''}`);
           }
+          io.log(`실측 점유: ${measure.members.map((m) => `${m.context} ${m.running === null || m.pending === null ? '못 쟀다' : m.running + m.pending}/${m.capacity}`).join(' · ') || '?'}`);
           io.log(`권장 지금 ${decision.recommended ?? '?'} 개 더 (limitedBy=${decision.limitedBy ?? 'unknown'})${decision.reason ? ` · ${decision.reason}` : ''}`);
           io.log(`예약(저작 중) ${host.reserved} · 대기 Job ${waitingJobs ?? '?'} · 실행 ${decision.running ?? '?'}`);
           io.log(`임대 없는 실행 ${decision.unleasedRunning ?? '?'}`);
@@ -155,6 +156,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         });
         if (result.image) io.error(`[pod] image ${result.image} · job ${result.job}`);
         io.log(result.artifactsDir);
+        if (result.artifacts?.error) io.error(`산출 회수 못 함: ${result.artifacts.error}`);
         io.exit(result.exitCode);
       } catch (err) {
         io.error(err instanceof Error ? err.message : String(err));

package/src/cli/pr-cli.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, relative, resolve } from 'node:path';
 import { createInterface } from 'node:readline';
 import type { Command } from 'commander';
@@ -19,6 +19,7 @@ import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runPublicLeakGate } from '../../scripts/ci-public-leak-gate.js';
 import { exportLeakCheck, publicExportChangedFiles, type ExportLeakCheck } from '../../scripts/ci-public-export-leak-gate.js';
+import { exportImportCheck, type ExportImportCheck } from '../../scripts/ci-public-export-import-gate.js';
 import { checkCommands, extractElanousCommands, type Finding as DocsCliFinding } from '../../scripts/docs-cli-check.js';
 import { runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
 import { isGoalDocumentFileName } from '../self-implement/goal-document.js';
@@ -111,6 +112,8 @@ export interface PrLandDeps {
   runPublicLeakGate?: (changedFiles: readonly string[], out: { log: (message: string) => void; error: (message: string) => void }) => number;
   /** Test seam — the post-transform export leak check on changed files. */
   runExportLeakCheck?: (changedFiles: readonly string[], cwd: string) => ExportLeakCheck;
+  /** Test seam — included files must not import a module the public export excludes. */
+  runExportImportCheck?: (changedFiles: readonly string[], cwd: string) => ExportImportCheck | Promise<ExportImportCheck>;
   /** 공개 문서의 `elanous …` 호출 ↔ 실제 `--help` 대조(경고 전용) — 바뀐 공개 문서 경로를 받아 어긋남 목록을 돌려준다. */
   runDocsCliCheck?: (docFiles: readonly string[]) => DocsCliFinding[];
   /** 변경 시험 파일 간 간섭 검사 심(시험 주입용). */
@@ -231,14 +234,14 @@ export async function decideOverlapLanding(input: {
 
 const liveOut = { log: (message: string) => console.log(message), error: (message: string) => console.error(message) };
 
-function runPrLandTypecheckGate(out: { log: (message: string) => void; error: (message: string) => void }): boolean {
+function runPrLandTypecheckGate(out: { log: (message: string) => void; error: (message: string) => void }, cwd: string = process.cwd()): boolean {
   let failed = false;
   const exit = ((code: number): never => {
     failed = code !== 0;
     throw new Error(`ci-typecheck-changed exited ${code}`);
   });
   try {
-    runChangedTypecheckGate({ log: out.log, warn: out.error, error: out.error, exit });
+    runChangedTypecheckGate({ log: out.log, warn: out.error, error: out.error, exit, cwd });
   } catch (error) {
     if (!failed) throw error;
   }
@@ -290,7 +293,67 @@ export function runPrLandExportLeakCheck(changedFiles: readonly string[], cwd: s
   return exportLeakCheck(changedFiles, top.status === 0 && String(top.stdout ?? '').trim() ? String(top.stdout).trim() : cwd);
 }
 
+/** Included files importing an excluded module — scripts/ci-public-export-import-gate.ts. cwd is the tree being landed. */
+export function runPrLandExportImportCheck(changedFiles: readonly string[], cwd: string): Promise<ExportImportCheck> {
+  const top = runGitCommand(cwd, ['rev-parse', '--show-toplevel'], { encoding: 'utf-8' });
+  return exportImportCheck(changedFiles, top.status === 0 && String(top.stdout ?? '').trim() ? String(top.stdout).trim() : cwd);
+}
+
+/** Blocks the landing when a changed public file imports a module the public export excludes. */
+export async function exportImportBlock(
+  changedFiles: readonly string[] | undefined,
+  check: () => ExportImportCheck | Promise<ExportImportCheck>,
+  out: { log: (message: string) => void; error: (message: string) => void },
+): Promise<boolean> {
+  if (!changedFiles || changedFiles.length === 0) return true;
+  let result: ExportImportCheck;
+  try { result = await check(); } catch { result = { measured: false, hits: [], unseen: 0, detail: '검사 실행 실패' }; }
+  const blocked = !result.measured || result.hits.length > 0;
+  record('public-export-import', !blocked, { measured: result.measured, hits: result.hits.length, unseen: result.unseen });
+  debug.log('pr.land', 'import-gate', { blocked, hits: result.hits.map(({ file, target }) => ({ file, target })), measured: result.measured, unseen: result.unseen });
+  if (!result.measured) {
+    out.error(`✗ public-export-import: 못 쟀다 — 막는다(${result.detail ?? '?'})`);
+    return false;
+  }
+  if (result.unseen > 0) out.log(`⚠ public-export-import: 비리터럴 지정자 ${result.unseen}곳은 못 봄`);
+  if (result.hits.length === 0) {
+    out.log('✓ public-export-import: 바뀐 공개 파일이 공개 내보내기에서 제외된 모듈을 import 하지 않는다.');
+    return true;
+  }
+  out.error(`✗ public-export-import: 공개 파일이 공개 내보내기에서 제외된 모듈을 import 한다 (${result.hits.length}곳) — 공개본 빌드가 여기서 깨진다:`);
+  for (const hit of result.hits.slice(0, 20)) out.error(`   ${hit.file}:${hit.line} → ${hit.target}`);
+  if (result.hits.length > 20) out.error(`   … 외 ${result.hits.length - 20}곳`);
+  return false;
+}
+
 /** Blocks changed public files that leak or cannot be measured. */
+/**
+ * MARKER-GUARD — a changed file that still holds merge-conflict markers is refused before landing.
+ * A file counts only when it has both a `<<<<<<< ` and a `>>>>>>> ` line (`=======` alone is a Markdown underline).
+ * 10-06 02:4x: a hand landing put three marker lines into release/next.md on main (hotfix #24333).
+ */
+export function conflictMarkerFiles(changedFiles: readonly string[] | undefined, cwd: string, read: (path: string) => string | undefined = (path) => {
+  // No size cutoff: a large file with markers must still be refused (ACP must-fix). A deleted file reads as undefined.
+  try { const full = resolve(cwd, path); return existsSync(full) && statSync(full).isFile() ? readFileSync(full, 'utf8') : undefined; }
+  catch { return undefined; }
+}): string[] {
+  return (changedFiles ?? []).filter((path) => {
+    const text = read(path);
+    return text !== undefined && /^<{7} /m.test(text) && /^>{7} /m.test(text);
+  });
+}
+
+export function conflictMarkerBlock(changedFiles: readonly string[] | undefined, cwd: string,
+  out: { log: (message: string) => void; error: (message: string) => void }, read?: (path: string) => string | undefined): boolean {
+  const hits = read ? conflictMarkerFiles(changedFiles, cwd, read) : conflictMarkerFiles(changedFiles, cwd);
+  if (hits.length) {
+    debug.log('pr.land', 'conflict-markers-blocked', { files: hits });
+    out.error(`✗ conflict-markers: 충돌 표시(<<<<<<< · >>>>>>>)가 남은 파일 ${hits.length}개 — ${hits.join(', ')} · 표시를 풀고 다시 착지하라`);
+    return false;
+  }
+  return true;
+}
+
 export function exportLeakBlock(
   changedFiles: readonly string[] | undefined,
   check: () => ExportLeakCheck,
@@ -401,8 +464,10 @@ function runPrLandDocsCliCheck(root: string): (docFiles: readonly string[]) => D
   return (docFiles) => checkCommands(docFiles.flatMap((f) => extractElanousCommands(f, readFileSync(join(root, f), 'utf8'))));
 }
 
-function runPrLandMockModuleRestoreGate(out: { log: (message: string) => void; error: (message: string) => void }): boolean {
-  return runMockModuleRestoreGate({ args: [], log: out.log, error: out.error }) === 0;
+function runPrLandMockModuleRestoreGate(out: { log: (message: string) => void; error: (message: string) => void }, cwd: string = process.cwd()): boolean {
+  const top = runGitCommand(cwd, ['rev-parse', '--show-toplevel'], { encoding: 'utf-8', env: { ...process.env, GIT_DIR: undefined, GIT_WORK_TREE: undefined, GIT_COMMON_DIR: undefined } as NodeJS.ProcessEnv });
+  const root = top.status === 0 && String(top.stdout ?? '').trim() ? String(top.stdout).trim() : cwd;
+  return runMockModuleRestoreGate({ args: [], cwd: root, log: out.log, error: out.error }) === 0;
 }
 
 // 🚨 안드로이드 축 — `bun test` 우주 «밖»이라 다른 게이트가 원리상 못 본다.
@@ -415,8 +480,9 @@ function runPrLandMockModuleRestoreGate(out: { log: (message: string) => void; e
 function runPrLandAndroidGate(
   out: { log: (message: string) => void; error: (message: string) => void },
   changedFiles: readonly string[] = [],
+  cwd: string = process.cwd(),
 ): boolean {
-  return runAndroidUnitTestGate({ args: ['--changed-files', ...changedFiles], log: out.log, error: out.error }) === 0;
+  return runAndroidUnitTestGate({ args: ['--changed-files', ...changedFiles], cwd, log: out.log, error: out.error }) === 0;
 }
 
 /** ⛔ 보호는 «호출부»에 둔다 — 주입된 게이트가 던져도 같은 계약이 서야 한다.
@@ -1320,7 +1386,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     }
   }
 
-  const typecheckOk = (deps.runTypecheckGate ?? runPrLandTypecheckGate)(out);
+  const typecheckOk = (deps.runTypecheckGate ?? ((o) => runPrLandTypecheckGate(o, cwd)))(out);
   record('typecheck', typecheckOk);
   if (!typecheckOk) {
     // ⛔⭐ 「왜 막혔나」를 «단정하지 않는다» — 이 게이트는 불리언만 돌려주므로 여기서는 이유를 모른다.
@@ -1347,7 +1413,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     out.log('✓ isolation-gate: scripts/ci-isolation-hardcode-gate.ts PASS — no new homedir+.elanous hardcoding.');
   }
 
-  const mockModuleRestore = gateVerdict('mock-module-restore-gate', deps.runMockModuleRestoreGate ?? runPrLandMockModuleRestoreGate, out);
+  const mockModuleRestore = gateVerdict('mock-module-restore-gate', deps.runMockModuleRestoreGate ?? ((o) => runPrLandMockModuleRestoreGate(o, cwd)), out);
   record('mock-module-restore-gate', mockModuleRestore.ok, { measured: mockModuleRestore.measured });
   if (!mockModuleRestore.ok) {
     out.error('✗ mock-module-restore-gate: scripts/ci-mock-module-restore-gate.ts blocked pr land because changed tests introduce mock.module without R-TST23 restoration.');
@@ -1361,7 +1427,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
   //   근본은 훈계가 아니라 ***분포***였다: 스크립트에 박힌 이름 중 «가장 흔한» 것이 ***낡은 것***이라
   //   옆 파일을 베끼면 낡은 이름을 물려받는다. ⇒ 이 자가 «신규»만 막는다(ratchet).
   //   ⚠️ `.github/workflows` 가 없어 `pr land` 가 «유일한» 강제점이다.
-  const modelHardcode = gateVerdict('model-hardcode-gate', deps.runModelHardcodeGate ?? ((o) => runModelHardcodeGate({ log: o.log, error: o.error, args: [] }) === 0), out);
+  const modelHardcode = gateVerdict('model-hardcode-gate', deps.runModelHardcodeGate ?? ((o) => runModelHardcodeGate({ log: o.log, error: o.error, args: [], cwd }) === 0), out);
   record('model-hardcode-gate', modelHardcode.ok, { measured: modelHardcode.measured });
   if (!modelHardcode.ok) {
     out.error('✗ model-hardcode-gate: scripts/ci-model-hardcode-gate.ts blocked pr land because changed files hardcode a model id — derive it from tierModel()/config instead.');
@@ -1382,15 +1448,17 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
 
   const changedPaths = currentChangePaths(run, cwd, staged, base, out);
   nextMdWarning(body ?? '', changedPaths, out);
+  if (!conflictMarkerBlock(changedPaths, cwd, out)) return 1;
   publicLeakWarning(changedPaths, deps.runPublicLeakGate ?? ((files, sink) => runPrLandPublicLeakGate(files, sink, cwd, base)), out);
   if (!exportLeakBlock(changedPaths, () => (deps.runExportLeakCheck ?? runPrLandExportLeakCheck)(changedPaths ?? [], cwd), opts.allowPublicLeak === true, out, cwd)) return 1;
+  if (!await exportImportBlock(changedPaths, () => (deps.runExportImportCheck ?? runPrLandExportImportCheck)(changedPaths ?? [], cwd), out)) return 1;
   if (publicDocPaths(changedPaths, () => true).length > 0) {
     const top = run('git', ['rev-parse', '--show-toplevel'], { cwd });
     const docsRoot = top.ok && top.out.trim() ? top.out.trim() : cwd;
     docsCliWarning(publicDocPaths(changedPaths, (f) => existsSync(join(docsRoot, f))), deps.runDocsCliCheck ?? runPrLandDocsCliCheck(docsRoot), out);
   }
   const testInterference = await testInterferenceGateVerdict(
-    deps.runTestInterferenceGate ?? ((o, files) => runTestInterferenceGate({ args: ['--changed-files', ...files], log: o.log })),
+    deps.runTestInterferenceGate ?? ((o, files) => runTestInterferenceGate({ args: ['--changed-files', ...files], log: o.log, cwd })),
     changedPaths,
     out,
   );
@@ -1400,7 +1468,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     'android-gate',
     deps.runAndroidGate
       ? (o) => deps.runAndroidGate!(o, changedPaths)
-      : (o) => runPrLandAndroidGate(o, changedPaths),
+      : (o) => runPrLandAndroidGate(o, changedPaths, cwd),
     out,
   );
   record('android-gate', androidGate.ok, { measured: androidGate.measured });
@@ -1418,7 +1486,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     'ios-gate',
     deps.runIosGate
       ? (o) => deps.runIosGate!(o, changedPaths)
-      : (o) => runIosUnitTestGate({ args: ['--changed-files', ...changedPaths], log: o.log, error: o.error }) === 0,
+      : (o) => runIosUnitTestGate({ args: ['--changed-files', ...changedPaths], cwd, log: o.log, error: o.error }) === 0,
     out,
   );
   record('ios-gate', iosGate.ok, { measured: iosGate.measured });