elanous 0.2.24 → 0.2.27

package/src/cli/friendly-errors.ts

@@ -0,0 +1,113 @@
+import { detectLocale, type Locale } from '../expression/locale.js';
+import { classifyError } from '../session-runtime/retry-policy.js';
+
+export type FriendlyErrorCode =
+  | 'credential-missing'
+  | 'provider-unknown'
+  | 'model-unavailable'
+  | 'network'
+  | 'quota'
+  | 'context-too-long'
+  | 'config-broken'
+  | 'daemon-down'
+  | 'permission'
+  | 'unknown-command';
+
+export interface FriendlyMessage {
+  what: string;
+  why: string;
+  next: string;
+}
+
+export type FriendlyLanguage = 'ko' | 'en';
+
+export const FRIENDLY_ERRORS: Readonly<Record<FriendlyErrorCode, Readonly<Record<FriendlyLanguage, FriendlyMessage>>>> = {
+  'credential-missing': {
+    ko: { what: '모델에 접속할 자격이 없습니다', why: '이 provider 에 로그인하지 않았거나 키가 없습니다', next: 'elanous login' },
+    en: { what: 'No credentials for this model provider', why: 'You have not signed in or set a key', next: 'elanous login' },
+  },
+  'provider-unknown': {
+    ko: { what: '설정된 provider 를 모릅니다', why: 'llm.provider 값이 지원 목록에 없습니다', next: 'elanous config get llm.provider' },
+    en: { what: 'Unknown model provider', why: 'llm.provider is not a supported name', next: 'elanous config get llm.provider' },
+  },
+  'model-unavailable': {
+    ko: { what: '이 모델을 쓸 수 없습니다', why: 'provider 와 모델이 맞지 않거나 모델이 없습니다', next: 'elanous config get llm.model' },
+    en: { what: 'This model is not available', why: 'The provider and model do not match, or the model does not exist', next: 'elanous config get llm.model' },
+  },
+  network: {
+    ko: { what: '서버에 연결하지 못했습니다', why: '네트워크가 끊겼거나 서버가 응답하지 않습니다', next: 'elanous doctor' },
+    en: { what: 'Could not reach the server', why: 'The network is down or the server did not answer', next: 'elanous doctor' },
+  },
+  quota: {
+    ko: { what: '사용 한도에 걸렸습니다', why: '이 계정의 할당량을 다 썼거나 요청이 너무 잦습니다', next: 'elanous usage' },
+    en: { what: 'Usage limit reached', why: 'The account quota is used up or requests are too frequent', next: 'elanous usage' },
+  },
+  'context-too-long': {
+    ko: { what: '입력이 너무 깁니다', why: '모델이 한 번에 읽는 양을 넘었습니다', next: 'elanous ask "<더 짧은 질문>"' },
+    en: { what: 'The input is too long', why: 'It exceeds what the model reads at once', next: 'elanous ask "<shorter question>"' },
+  },
+  'config-broken': {
+    ko: { what: '설정 파일을 읽지 못했습니다', why: 'config 파일의 JSON 이 깨졌습니다', next: 'elanous doctor --fix' },
+    en: { what: 'Could not read the config file', why: 'The config JSON is malformed', next: 'elanous doctor --fix' },
+  },
+  'daemon-down': {
+    ko: { what: '엘라누스 데몬이 떠 있지 않습니다', why: '백그라운드 서비스가 꺼져 있습니다', next: 'elanous nexus' },
+    en: { what: 'The elanous daemon is not running', why: 'The background service is stopped', next: 'elanous nexus' },
+  },
+  permission: {
+    ko: { what: '파일에 접근할 권한이 없습니다', why: '이 사용자로 그 경로를 읽거나 쓸 수 없습니다', next: 'elanous doctor' },
+    en: { what: 'Permission denied', why: 'This user cannot read or write that path', next: 'elanous doctor' },
+  },
+  'unknown-command': {
+    ko: { what: '모르는 명령입니다', why: '명령 이름이 틀렸거나 이 판에 없습니다', next: 'elanous --help' },
+    en: { what: 'Unknown command', why: 'The name is misspelled or not in this version', next: 'elanous --help' },
+  },
+};
+
+function messageOf(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  return typeof err === 'string' ? err : '';
+}
+
+function errnoOf(err: unknown): string {
+  if (err && typeof err === 'object') {
+    const code = (err as { code?: unknown }).code;
+    if (typeof code === 'string') return code;
+  }
+  return '';
+}
+
+/** Maps a thrown value to a friendly-error code by its wording and by the
+ *  retry-policy category. Returns null when nothing matches. */
+export function classifyFriendlyError(err: unknown): FriendlyErrorCode | null {
+  const msg = messageOf(err);
+  const errno = errnoOf(err);
+
+  if (/provider-model compatibility/i.test(msg)) return 'model-unavailable';
+  if (/\bunknown provider:/i.test(msg)) return 'provider-unknown';
+  if (/\bunavailable:\s+(set|run|configure)\b/i.test(msg)) return 'credential-missing';
+  if (/the elanous daemon is not running/i.test(msg)) return 'daemon-down';
+  if (/unknown command '/i.test(msg)) return 'unknown-command';
+  if (/input exceeds the \d+-token context budget/i.test(msg)) return 'context-too-long';
+  if (
+    /Unexpected token .*JSON|JSON Parse error|is not valid JSON|JSON at position/i.test(msg) ||
+    (err instanceof Error && err.name === 'SyntaxError' && /json/i.test(msg))
+  ) return 'config-broken';
+  if (errno === 'EACCES' || errno === 'EPERM' || /\b(EACCES|EPERM)\b/.test(msg)) return 'permission';
+
+  switch (classifyError(err)) {
+    case 'network-transient': return 'network';
+    case 'quota-exceeded':
+    case 'rate-limit': return 'quota';
+    case 'context-window-exceeded': return 'context-too-long';
+    case 'provider-unavailable': return 'credential-missing';
+    default: return null;
+  }
+}
+
+/** Renders one language only (ko, otherwise en). The last line is the one command to run. */
+export function formatFriendlyError(code: FriendlyErrorCode, locale: Locale = detectLocale()): string {
+  const language: FriendlyLanguage = locale === 'ko' ? 'ko' : 'en';
+  const { what, why, next } = FRIENDLY_ERRORS[code][language];
+  return `❌ ${what}\n  ↳ ${why}\n  ${next}`;
+}

package/src/cli/intake-cli.ts

@@ -173,7 +173,9 @@ export async function runIntakeDigestCli(
         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 });
+    const judgedCount = (entries: { verdict: string }[] | undefined) => (entries ?? []).filter((entry) => entry.verdict !== '판정 대기').length;
+    debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length,
+      github: d.githubNew?.length ?? 0, githubJudged: judgedCount(d.githubNew), x: d.xTrends?.length ?? 0, xJudged: judgedCount(d.xTrends), sent });
     if (seat && sent) recordSeatBriefed(root, seat, day, d.absorbed.map((entry) => entry.id));
     if (seat === 'user') debug.log('watch.default', 'brief', { topics: (await import('../intake-plane/intake-sources.js')).listSources({ seat }, root).length, items: d.absorbed.length, sent });
     console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');

package/src/cli/memory-cli.ts

@@ -0,0 +1,182 @@
+/**
+ * `elanous memory` 명령 묶음 등록 — BIG-FILE-index-1 첫 조각(순수 이동 · src/index.ts → src/cli/memory-cli.ts).
+ * 로직·문면·옵션·종료 코드는 이동 원본과 동일하다.
+ */
+import type { Command } from 'commander';
+import * as ui from '../ui.js';
+import { readPipedStdin } from './piped-stdin.js';
+import {
+  saveMemory, loadMemory, listMemories, deleteMemory, searchMemories,
+  readIndex, memoryRoot, memoryIndexPath,
+  type MemoryType,
+} from '../memory.js';
+
+export function registerMemoryCommands(program: Command): void {
+  const memCmd = program.command('memory').description('Persistent memories injected into every chat turn (user / feedback / project / reference)');
+
+  memCmd
+  .command('list [type]')
+  .description('List memories (optionally filtered by type)')
+  .option('-n, --limit <n>', 'Max entries to show', '30')
+  .action((type?: string, opts?: { limit: string }) => {
+    const t = type as MemoryType | undefined;
+    const entries = listMemories({ type: t, limit: parseInt(opts?.limit ?? '30', 10) });
+    if (entries.length === 0) {
+      ui.info('No memories yet. Add one with `elanous memory add <type> "<name>" "<description>"`.');
+      return;
+    }
+    ui.header(`memories (${entries.length})`);
+    for (const e of entries) {
+      console.log(`  ${e.id.slice(0, 8)}  [${e.type.padEnd(9)}]  ${e.name}`);
+      if (e.description) console.log(`             ${e.description.slice(0, 100)}`);
+    }
+  });
+
+  memCmd
+  .command('add <type> <name> [description...]')
+  .description('Create a memory (type: user|feedback|project|reference). Body piped via stdin if available.')
+  .action(async (type: string, name: string, descParts: string[]) => {
+    if (!['user', 'feedback', 'project', 'reference'].includes(type)) {
+      ui.error(`invalid type "${type}". Use: user | feedback | project | reference`);
+      process.exit(1);
+    }
+    const description = (descParts || []).join(' ');
+    // Read body from stdin if piped; otherwise use description as body too.
+    let body = description;
+    const pipedBody = await readPipedStdin();   // ★ OBS-T3 — 비-TTY 는 파이프를 뜻하지 않는다(소켓이면 EOF 가 안 온다)
+    if (pipedBody) body = pipedBody;
+    const e = saveMemory({ type: type as MemoryType, name, description, body });
+    ui.info(`saved ${e.id.slice(0, 8)} [${e.type}] "${e.name}"`);
+  });
+
+  // 3번째 recall 레버(2026-07-19) — pin(항상주입) / priority(매칭 시 순위 부스트).
+  memCmd
+  .command('pin <idPrefix>')
+  .description('Pin a memory so it is ALWAYS injected (bypass keyword gate). Optionally set priority.')
+  .option('-p, --priority <n>', 'priority boost (higher = ranked/kept first)', '5')
+  .action((prefix: string, opts: { priority: string }) => {
+    const e = loadMemory(prefix);
+    if (!e) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    saveMemory({ type: e.type, name: e.name, description: e.description, body: e.body, id: e.id, pinned: true, priority: parseInt(opts.priority, 10) || 0 });
+    ui.info(`📌 pinned ${e.id.slice(0, 8)} "${e.name}" (priority ${opts.priority})`);
+  });
+
+  memCmd
+  .command('unpin <idPrefix>')
+  .description('Un-pin a memory (back to keyword-gated recall).')
+  .action((prefix: string) => {
+    const e = loadMemory(prefix);
+    if (!e) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    saveMemory({ type: e.type, name: e.name, description: e.description, body: e.body, id: e.id, pinned: false, priority: e.priority });
+    ui.info(`unpinned ${e.id.slice(0, 8)} "${e.name}"`);
+  });
+
+  memCmd
+  .command('priority <idPrefix> <n>')
+  .description('Set a memory\'s injection priority boost (0 = default). Added to match score.')
+  .action((prefix: string, n: string) => {
+    const e = loadMemory(prefix);
+    if (!e) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    saveMemory({ type: e.type, name: e.name, description: e.description, body: e.body, id: e.id, priority: parseInt(n, 10) || 0, pinned: e.pinned });
+    ui.info(`priority ${e.id.slice(0, 8)} "${e.name}" → ${parseInt(n, 10) || 0}`);
+  });
+
+  // 통합 관리 뷰(2026-07-19) — 2 시스템(큐레이션 파일메모리 + 에피소드 self-log)을 한 화면에.
+  memCmd
+  .command('status')
+  .description('Unified memory overview — ① curated file-memory + ② self-log (surface_events)')
+  .action(async () => {
+    const { memoryRoot } = await import('../memory.js');
+    const mems = listMemories();
+    const byType: Record<string, number> = {};
+    let pinned = 0;
+    for (const e of mems) { byType[e.type] = (byType[e.type] ?? 0) + 1; if (e.pinned) pinned += 1; }
+    ui.header('memory (unified)');
+    console.log(`① 큐레이션 파일메모리: ${mems.length}건  [${Object.entries(byType).map(([k, v]) => `${k}:${v}`).join(' ') || '-'}]  📌pinned ${pinned}`);
+    console.log(`   ${memoryRoot()}  (LLM-judge/luna recall · MEMORY.md 항상주입)`);
+    try {
+      const { surfaceEventsDbPath, openSurfaceEventsDb } = await import('../domains/surface-events.js');
+      const path = surfaceEventsDbPath();
+      // 항상 open — legacy conatus/ → memory/ 자가치유 마이그레이션이 여기서 실행된다(존재 체크 먼저
+      // 하면 신 경로 부재로 마이그레이션이 스킵됨). 없으면 빈 store 생성(무해).
+      const db = openSurfaceEventsDb(path);
+      const n = (db.prepare('SELECT count(*) c FROM events').get() as { c: number }).c;
+      const recent = (db.prepare('SELECT ts FROM events ORDER BY ts DESC LIMIT 1').get() as { ts: string } | undefined)?.ts;
+      db.close();
+      console.log(`② 에피소드 self-log: ${n.toLocaleString()} events  (최근 ${recent?.slice(0, 16) ?? '-'})`);
+      console.log(`   ${path}  (FTS5 bm25+recency+myelin rerank · ambient 회상)`);
+    } catch (e) { console.log(`② self-log 조회 실패: ${(e as Error).message}`); }
+    try {
+      const { openKnowledgeDb, knowledgeDbPath } = await import('../domains/knowledge.js');
+      const kdb = openKnowledgeDb(); // 기본 경로 → legacy conatus/ 자가치유 이전
+      const kn = (kdb.prepare('SELECT count(*) c FROM docs').get() as { c: number }).c;
+      const dom = (kdb.prepare("SELECT domain, count(*) c FROM docs GROUP BY domain ORDER BY c DESC LIMIT 3").all() as Array<{ domain: string | null; c: number }>);
+      kdb.close();
+      console.log(`③ 시맨틱 knowledge: ${kn.toLocaleString()} docs  [${dom.map(d => `${d.domain ?? 'null'}:${d.c}`).join(' ')}]`);
+      console.log(`   ${knowledgeDbPath()}  (임베딩 벡터+BM25 하이브리드 · 의미 회상)`);
+    } catch (e) { console.log(`③ knowledge 조회 실패: ${(e as Error).message}`); }
+  });
+
+  memCmd
+  .command('show <idPrefix>')
+  .description('Print full memory body')
+  .action((prefix: string) => {
+    const entries = listMemories();
+    const hit = entries.find(e => e.id.startsWith(prefix));
+    if (!hit) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    const full = loadMemory(hit.id)!;
+    ui.header(`${full.type}: ${full.name}`);
+    console.log(`  id          ${full.id}`);
+    console.log(`  created     ${full.createdAt}`);
+    console.log(`  updated     ${full.updatedAt}`);
+    console.log(`  description ${full.description}`);
+    console.log('');
+    console.log(full.body);
+  });
+
+  memCmd
+  .command('search <query...>')
+  .description('Keyword search across all memories')
+  .option('--type <t>', 'Filter by type')
+  .option('-n, --limit <n>', 'Max results', '10')
+  .action((parts: string[], opts) => {
+    const hits = searchMemories(parts.join(' '), {
+      type: opts.type as MemoryType | undefined,
+      limit: parseInt(opts.limit, 10),
+    });
+    if (hits.length === 0) { ui.info('No matches.'); return; }
+    ui.header(`matches (${hits.length})`);
+    for (const h of hits) {
+      console.log(`  ${h.entry.id.slice(0, 8)}  score ${h.score}  [${h.entry.type}]  ${h.entry.name}`);
+      if (h.entry.description) console.log(`             ${h.entry.description.slice(0, 100)}`);
+    }
+  });
+
+  memCmd
+  .command('delete <idPrefix>')
+  .description('Delete a memory')
+  .action((prefix: string) => {
+    const entries = listMemories();
+    const hit = entries.find(e => e.id.startsWith(prefix));
+    if (!hit) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    deleteMemory(hit.id);
+    ui.info(`deleted ${hit.id.slice(0, 8)}`);
+  });
+
+  memCmd
+  .command('index')
+  .description('Print MEMORY.md index verbatim')
+  .action(() => {
+    const idx = readIndex();
+    if (!idx) { ui.info('empty (no memories yet)'); return; }
+    console.log(idx);
+  });
+
+  memCmd
+  .command('where')
+  .description('Show the memory storage path')
+  .action(() => {
+    console.log(`memory dir   ${memoryRoot()}`);
+    console.log(`index file   ${memoryIndexPath()}`);
+  });
+}

package/src/cli/model-watch-cli.ts

@@ -5,7 +5,7 @@ import { loadCatalog, type CatalogIoOpts } from '../intelligence-map/model-catal
 import { getModelWatchProposalPath, runModelIntelligenceWatch, type ModelWatchDeps } from '../intelligence-map/model-watch-mission.js';
 import { fetchProviderModelPages, type ModelWatchFetchResult } from '../intelligence-map/model-watch-fetch.js';
 import type { ModelCandidate } from '../intelligence-map/model-classifier.js';
-import type { WatchIntakeResult } from '../intelligence-map/model-watch-intake.js';
+import { detectPriceChanges, formatPriceChange, type PriceChange, type WatchIntakeResult } from '../intelligence-map/model-watch-intake.js';
 import type { LlmRunner } from '../model-tier/preset-suggest-llm.js';
 
 export interface ModelWatchCliResult {
@@ -14,6 +14,7 @@ export interface ModelWatchCliResult {
   failures: ModelWatchFetchResult['failures'];
   proposal: Pick<WatchIntakeResult['proposal'], 'added' | 'updated'>;
   candidates: WatchIntakeResult['candidates'];
+  priceChanges: PriceChange[];
   perSource: WatchIntakeResult['perSource'];
 }
 
@@ -93,6 +94,7 @@ export async function runModelWatchCli(deps: ModelWatchCliDeps = {}): Promise<Mo
     failures: fetched.failures,
     proposal: { added: intake.proposal.added, updated: intake.proposal.updated },
     candidates: intake.candidates,
+    priceChanges: detectPriceChanges(intake),
     perSource: intake.perSource,
   };
 }
@@ -103,6 +105,7 @@ export function formatModelWatchResult(result: ModelWatchCliResult): string {
     `Proposal: ${result.proposal.added.length} added, ${result.proposal.updated.length} updated (not applied).`,
   ];
   if (result.candidates.length > 0) lines.push(`Candidates: ${result.candidates.map((candidate) => candidate.id).join(', ')}`);
+  if (result.priceChanges.length > 0) lines.push(`Price changes: ${result.priceChanges.map(formatPriceChange).join('; ')}`);
   const abnormalEmptySources = Object.entries(result.perSource)
     .filter(([, source]) => source.candidateCount === 0 && source.status !== 'completed')
     .map(([source]) => source);

package/src/cli/msg-cli.ts

@@ -57,13 +57,17 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
   };
 
   msg.command('post [body]').description('Post a message; use - or omit body to read stdin')
-    .option('--from <seat>').option('--to <seat>').option('--kind <kind>').option('--body <text>').option('--json')
-    .action((body: string | undefined, opts: CommonOptions & { from?: string; to?: string; kind?: string; body?: string }) => run(async () => {
+    .option('--from <seat>').option('--to <seat>').option('--kind <kind>').option('--body <text>')
+    .option('--origin-key <key>', 'deduplicate a channel mirror by coord:<commentId>:<recipient>').option('--json')
+    .action((body: string | undefined, opts: CommonOptions & { from?: string; to?: string; kind?: string; body?: string; originKey?: string }) => run(async () => {
       const from = seat(opts.from, '--from');
       const to = seat(opts.to, '--to');
       if (body !== undefined && body !== '-' && opts.body !== undefined) throw new Error('provide body once (argument or --body)');
       const text = opts.body ?? (body !== undefined && body !== '-' ? body : await readStdin());
-      const posted = withStore(store => store.post({ from, to, body: text, ...(opts.kind === undefined ? {} : { kind: opts.kind }) }));
+      const envelope = { from, to, body: text, ...(opts.kind === undefined ? {} : { kind: opts.kind }) };
+      const posted = withStore(store => opts.originKey === undefined
+        ? store.post(envelope)
+        : store.appendWithProvenance(envelope, opts.originKey));
       emit(posted, opts.json, () => out.log(formatMessage(posted)));
     })());
 
@@ -95,7 +99,11 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
     .option('--to <seat>').option('--json')
     .action((opts: CommonOptions & { to?: string }) => run(() => {
       const to = opts.to === undefined ? undefined : seat(opts.to, '--to');
-      const rows = withStore(store => store.unread().filter(row => to === undefined || row.recipient === to));
+      const rows = withStore(store => {
+        if (to === undefined) return store.unread();
+        const count = store.unreadCount(to);
+        return count ? [{ recipient: to, count }] : [];
+      });
       emit(rows, opts.json, () => {
         if (!rows.length) out.log('No unread messages.');
         for (const row of rows) out.log(`${row.recipient}: ${row.count} unread`);
@@ -104,9 +112,11 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
 
   msg.command('watch').description('Poll for new messages without acknowledging them (Ctrl-C to stop)')
     .option('--to <seat>').option('--after <id>', 'exclusive message ID (default: acknowledged cursor)')
+    .option('--since-ack', 'start from the recipient seat’s acknowledged cursor')
     .option('--interval <ms>', 'poll interval in milliseconds', '1000')
     .option('--once', 'poll once and exit').option('--json')
-    .action((opts: RecipientOptions & { interval?: string; once?: boolean }) => run(async () => {
+    .action((opts: RecipientOptions & { interval?: string; once?: boolean; sinceAck?: boolean }) => run(async () => {
+      if (opts.sinceAck && opts.after !== undefined) throw new Error('--since-ack cannot be used with --after');
       const to = seat(opts.to, '--to');
       const interval = integer(opts.interval, '--interval', 1000, 1, 60000);
       const after = opts.after === undefined ? undefined : integer(opts.after, '--after', 0, 0, Number.MAX_SAFE_INTEGER);

package/src/cli/pr-cli.ts

@@ -1195,6 +1195,59 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
   const cwd = opts.cwd ?? process.cwd();
   const run = deps.run ?? defaultCmdRunner;
   const pinned = opts.pr !== undefined || opts.expectedHead !== undefined;
+  if (opts.dryRun && opts.pr !== undefined && opts.expectedHead === undefined) {
+    if (opts.overlapEvidence !== undefined || opts.hold) {
+      out.error('✗ dry-run: --overlap-evidence 와 --hold 는 번호 지정 읽기 전용 미리보기에서 사용할 수 없습니다.');
+      return 1;
+    }
+    const pr = Number(opts.pr);
+    if (!/^[1-9]\d*$/.test(opts.pr) || !Number.isSafeInteger(pr)) {
+      out.error('✗ dry-run: --pr 에는 양의 정수를 지정해야 합니다.');
+      return 1;
+    }
+    const viewed = run('gh', ['pr', 'view', String(pr), '--json', 'headRefOid,state,headRefName,isDraft,mergeable,mergeStateStatus,url'], { cwd });
+    if (!viewed.ok) {
+      out.error(`✗ dry-run: PR #${pr} 를 조회하지 못했습니다 — 존재하지 않거나 GitHub 조회가 실패했습니다.`);
+      return 1;
+    }
+    let value: { headRefOid?: string; state?: string; headRefName?: string; isDraft?: boolean; mergeable?: string; mergeStateStatus?: string; url?: string };
+    try {
+      const parsed: unknown = JSON.parse(viewed.out);
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('not an object');
+      value = parsed as typeof value;
+    }
+    catch {
+      out.error(`✗ dry-run: PR #${pr} 조회 결과를 읽을 수 없습니다.`);
+      return 1;
+    }
+    if (typeof value.headRefOid !== 'string' || !/^[a-f0-9]{40}$/i.test(value.headRefOid) || value.state !== 'OPEN') {
+      out.error(`✗ dry-run: PR #${pr} 가 열려 있지 않거나 head 정보가 없습니다 (state=${value.state ?? 'unmeasured'}).`);
+      return 1;
+    }
+    out.log(`PR #${pr} · head ${value.headRefOid} · state ${value.state}${value.headRefName ? ` · branch ${value.headRefName}` : ''}`);
+    out.log('Landing plan (read-only preview):');
+    out.log(`- GitHub PR state/head: PASS (${value.state}, ${value.headRefOid})`);
+    if (value.isDraft === true) out.log('- Draft status: GitHub reports DRAFT; landing eligibility UNMEASURED.');
+    else if (value.isDraft === false) out.log('- Draft status: observed — ready for review.');
+    else if (value.isDraft !== false) out.log('- Draft status: UNMEASURED');
+    if (value.mergeable === 'CONFLICTING') out.log('- Warning: GitHub reports merge conflicts; landing eligibility UNMEASURED.');
+    else if (value.mergeable === 'MERGEABLE') out.log('- Mergeability: GitHub reports MERGEABLE; repository landing gates remain UNMEASURED.');
+    else out.log(`- Mergeability: UNMEASURED${value.mergeable ? ` (${value.mergeable})` : ''}`);
+    if (value.mergeStateStatus === 'BLOCKED' || value.mergeStateStatus === 'DIRTY' || value.mergeStateStatus === 'DRAFT') {
+      out.log(`- Warning: GitHub merge state is ${value.mergeStateStatus}; landing eligibility UNMEASURED.`);
+    } else if (value.mergeStateStatus && value.mergeStateStatus !== 'CLEAN') {
+      out.log(`- GitHub merge state: ${value.mergeStateStatus} (additional requirements may apply; landing eligibility UNMEASURED).`);
+    }
+    out.log('- Local HEAD/worktree, branch/base, and same-branch guard: UNMEASURED — local git is not run');
+    out.log('- Changed-file scope, active-run files, untracked files, plan artifacts, and deletion advisory: UNMEASURED — local files are not read');
+    out.log('- Typecheck, isolation, mock-module restore, model-hardcode, daemon-port, test-interference, and global checks: UNMEASURED — gates are not run');
+    out.log('- Public export/import, public leak, and docs CLI checks: UNMEASURED — gates are not run');
+    out.log('- Android, iOS, and PWA gates: CONDITIONAL / UNMEASURED — changed-file applicability and builds are not checked');
+    out.log('- Freeze, PR base/bench guards, sibling PRs, recent landings, overlap, and approval: UNMEASURED — not queried or approved');
+    out.log('- GitHub draft/mergeability status: observed above; this preview does not approve or merge the PR.');
+    out.log('- Mutations (ready/edit/create/merge, git commit/push, worktree): NOT RUN');
+    return 0;
+  }
   if (opts.overlapEvidence !== undefined && (!pinned || !opts.overlapEvidence.trim())) {
     out.error('✗ overlap-evidence: --overlap-evidence <file> 는 --pr ⊕ --expected-head 머리 고정 착지에서만 쓴다.');
     return 1;

package/src/cli/pr-land-overlap-evidence.ts

@@ -11,12 +11,12 @@
  *      ⓐ `gate.baseCommit` 이 고정 머리의 조상 ⊕ 지금 끝의 조상이고 ⓑ 창 `gate.baseCommit..지금 끝`의 커밋이 «하나도»
  *      PR 의 바뀐 파일(머리 vs merge-base)을 안 건드리면 통과(관측 reason `base-advanced-disjoint`).
  *      겹치면 `base-stale-overlap`(REJUDGE 가 재게이트를 청한다) · 못 재면 `base-window-unmeasured` · ⓐ 가 아니면 종전 사유.
- *   ③ 리뷰 — 증거가 가리키는 `review-results/<card>-<pr>-<head12>.json`(TA 가 받는 `self review --json` stdout)이
- *      같은 PR·같은 머리에 대해 `reviewed:true` · `verdict ∈ {pass, warn}` · must-fix 가 «잰 수» 0 인가
+ *   ③ 리뷰 — 증거가 가리키는 `review-results/<card>-<pr>-<head접두 10~40>.json`(TA 가 받는 `self review --json` stdout)이
+ *      파일명에서 같은 PR·머리 접두이고 내용에서 전체 PR·머리가 정확히 같으며 `reviewed:true` · `verdict ∈ {pass, warn}` · must-fix 가 «잰 수» 0 인가
  *      (자동 병합 canAuto · TA-LAND-WARN-MUSTFIX0 과 같은 규칙 — must-fix 를 못 셌으면 거부).
  *   ⓐ 이미 조상(TC #26019 실측) — 겹친 최근 착지 커밋이 «전부» 고정 머리의 조상이면 그 겹침은 이미 그 머리의 게이트·리뷰에
  *      반영됐다 ⇒ ①② 없이 ③ 만으로 통과(관측 reason `already-ancestor`). 하나라도 조상이 아니면 ①②③ 전부.
- *   ⓐ' 증거 파일이 없을 때(`verifyAncestorAutoPass`) — 같은 ⓐ 를 표준 자리 `review-results/*-<pr>-<head12>.json` 만으로 잰다
+ *   ⓐ' 증거 파일이 없을 때(`verifyAncestorAutoPass`) — 같은 ⓐ 를 표준 자리 `review-results/*-<pr>-<head접두 10~40>.json` 만으로 잰다
  *      (관측 reason `already-ancestor-auto`). 조상이 아닌 착지가 하나라도 있거나 리뷰 결과가 없으면 거부.
  *   하나라도 못 재거나 어긋나면 거부 — 호출부는 종전 거부를 그대로 낸다(fail-closed).
  * - 관측: `pr.land` · `overlap-evidence` (decision · reason · 잰 값).
@@ -33,7 +33,7 @@ interface OverlapEvidenceFile {
   head: string;
   /** ①② 경로에서만 필수 — 겹친 착지가 전부 조상(already-ancestor)이면 생략해도 된다. */
   gate?: { head: string; baseCommit: string; passed: boolean };
-  /** `self review --json` stdout 을 받은 파일(TA: `<state>/review-results/<card>-<pr>-<head12>.json`). */
+  /** `self review --json` stdout 을 받은 파일(TA: `<state>/review-results/<card>-<pr>-<head접두 10~40>.json`); 내용의 전체 head도 확인한다. */
   reviewResult: string;
 }
 
@@ -65,9 +65,14 @@ const COMMIT_MARK = '\u0001';
 
 function checkReview(input: Pick<VerifyOverlapEvidenceInput, 'pr' | 'readFile'>, e: Partial<OverlapEvidenceFile>, head: string, baseTip?: string): { ok: false; reason: string; baseTip?: string } | { ok: true; reviewResult: string } {
   if (typeof e.reviewResult !== 'string' || !e.reviewResult) return { ok: false, reason: 'review-missing', baseTip };
-  // TA 가 받는 자리(`<state>/review-results/<card>-<pr>-<head12>.json` · reviewResultPath)만 — 아무 디렉터리의 같은 이름은 안 받는다.
+  // TA 가 받는 자리(`<state>/review-results/<card>-<pr>-<head접두 10~40>.json` · reviewResultPath)만; 내용의 전체 head도 확인한다.
+  const resultName = basename(e.reviewResult);
+  const resultMatch = /^([A-Za-z0-9][A-Za-z0-9._-]*)-(\d+)-([a-f0-9]{10,40})\.json$/i.exec(resultName);
   if (basename(dirname(e.reviewResult)) !== 'review-results'
-    || !new RegExp(`^[A-Za-z0-9][A-Za-z0-9._-]*-${input.pr}-${head.slice(0, 12)}\\.json$`, 'i').test(basename(e.reviewResult))) {
+    || !resultMatch
+    || Number(resultMatch[2]) !== input.pr
+    || resultMatch[3]!.length < 10
+    || !head.startsWith(resultMatch[3]!.toLowerCase())) {
     return { ok: false, reason: 'review-path-not-for-this-pr-head', baseTip };
   }
   let text: string;
@@ -206,7 +211,7 @@ export interface VerifyAncestorAutoInput {
   cwd: string;
   run: CmdRunner;
   readFile: (path: string) => string;
-  /** 표준 자리 `<state>/review-results` — 이 안의 `*-<pr>-<head12>.json` 만 본다. */
+  /** 표준 자리 `<state>/review-results` — 이 안의 `*-<pr>-<head접두 10~40>.json`만 후보로 보고 내용의 전체 head를 확인한다. */
   reviewResultsDir: string;
   listDir: (dir: string) => readonly string[];
   /** 겹침 관문이 찾은 «겹친» 최근 착지 커밋들. */
@@ -222,10 +227,13 @@ function checkAncestorAuto(input: VerifyAncestorAutoInput): AncestorAutoVerdict
   if (notAncestor !== undefined) return { ok: false, reason: `ancestor-auto-not-ancestor: ${notAncestor.slice(0, 12)} is not an ancestor of ${head.slice(0, 12)}` };
   let names: readonly string[];
   try { names = input.listDir(input.reviewResultsDir); } catch { return { ok: false, reason: 'review-missing' }; }
-  const suffix = new RegExp(`-${input.pr}-${head.slice(0, 12)}\\.json$`, 'i');
-  // 같은 <pr>-<head12> 리뷰가 여럿이면 «전부» 통과해야 한다 — 하나라도 거부면 거부(fail-closed · 처음 통과한 하나로 승인하지 않는다).
+  const filename = new RegExp(`^[A-Za-z0-9][A-Za-z0-9._-]*-${input.pr}-([a-f0-9]{10,40})\\.json$`, 'i');
+  // 같은 PR·머리 접두의 리뷰가 여럿이면 «전부» 통과해야 한다 — 내용 headCommit 이 정확히 맞아야 승인한다.
   let accepted: string | undefined;
-  for (const name of [...names].filter((n) => suffix.test(n)).sort()) {
+  for (const name of [...names].filter((n) => {
+    const match = filename.exec(n);
+    return Boolean(match && match[1]!.length >= 10 && head.startsWith(match[1]!.toLowerCase()));
+  }).sort()) {
     const review = checkReview(input, { reviewResult: join(input.reviewResultsDir, name) }, head);
     if (!review.ok) return { ok: false, reason: review.reason };
     accepted = review.reviewResult;

package/src/cli/pr-land-pod-shadow.ts

@@ -0,0 +1,54 @@
+/**
+ * PRLAND-HEAVY-ON-POD-1 — `pr land` 무거운 판정을 Pod 에서 그림자 리허설한다.
+ *
+ * 착지 경로에 아직 잇지 않는다. `--heavy-on-pod-shadow` 플래그·실제 Pod 러너 바인딩은
+ * 다음 조각(pr-cli.ts · pod-command-job.ts 무접촉). 이번 단위는 주입형 순수 함수만:
+ * 켜지면 가짜/실 Pod 러너를 한 번 부르고 `pr.land`/`heavy-on-pod-shadow` 관측 한 줄을 남긴 뒤
+ * 로컬 판정을 그대로 반환한다. 끄면 러너 0회. 러너가 던져도 경고 한 줄만 내고 로컬을 지킨다.
+ */
+
+export interface HeavyOnPodShadowInput<T> {
+  enabled: boolean;
+  pr: number;
+  head: string;
+  local: T;
+  runPod: () => T | Promise<T>;
+  log: (category: string, event: string, data: Record<string, unknown>) => void;
+  warn: (message: string) => void;
+}
+
+function agree(local: unknown, pod: unknown): boolean {
+  if (Object.is(local, pod)) return true;
+  try {
+    return JSON.stringify(local) === JSON.stringify(pod);
+  } catch {
+    return false;
+  }
+}
+
+function elapsedMs(started: number): number {
+  return Math.max(0, performance.now() - started);
+}
+
+export async function runHeavyOnPodShadow<T>(input: HeavyOnPodShadowInput<T>): Promise<T> {
+  const { enabled, pr, head, local, runPod, log, warn } = input;
+  if (!enabled) return local;
+
+  const localMs = 0;
+  const started = performance.now();
+  try {
+    const pod = await runPod();
+    log('pr.land', 'heavy-on-pod-shadow', {
+      pr,
+      head,
+      local,
+      pod,
+      agree: agree(local, pod),
+      podMs: elapsedMs(started),
+      localMs,
+    });
+  } catch (error) {
+    warn(error instanceof Error ? error.message : String(error));
+  }
+  return local;
+}