elanous 0.2.23 → 0.2.25

package/src/cli/image-cli.ts

@@ -0,0 +1,101 @@
+import type { Command } from 'commander';
+import { debug } from '../debug/log.js';
+import {
+  appendImageLedgerEvent, baselinePinEvent, foldImageLedger, imageLedgerPath, readImageLedger, readRegistryTags,
+  type ImageLedgerRow, type RegistryRead,
+} from '../images/image-ledger.js';
+import { isPodImageCommit, podImageRegistry } from '../task-orchestrator/surfaces/pod-image-source.js';
+
+const SSH_HOST = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/u;
+
+export interface ImageLsDeps {
+  readonly ledgerPath?: string;
+  readonly readRegistry?: (opts: { port: string; sshHost?: string }) => RegistryRead;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly out?: (line: string) => void;
+}
+
+export interface ImageLsResult {
+  readonly ledger: { readonly path: string; readonly exists: boolean; readonly events: number; readonly unreadableLines: number };
+  readonly registry: { readonly read: boolean; readonly where: string; readonly tags: number | null; readonly reason?: string };
+  readonly rows: readonly ImageLedgerRow[];
+  readonly counts: { readonly baseline: number; readonly transient: number | null; readonly ledgered: number };
+}
+
+/** `image ls` — read only: ledger rows ⊕ registry tags without a ledger row (= transient). */
+export function imageLs(opts: { json?: boolean; ssh?: string; registry?: boolean }, deps: ImageLsDeps = {}): ImageLsResult {
+  const out = deps.out ?? ((line: string) => console.log(line));
+  if (opts.ssh !== undefined && !SSH_HOST.test(opts.ssh)) throw new Error(`invalid --ssh host: ${opts.ssh}`);
+  const ledger = readImageLedger(deps.ledgerPath ?? imageLedgerPath());
+  const registryAddr = podImageRegistry(deps.env ?? process.env);
+  const port = registryAddr.slice(registryAddr.lastIndexOf(':') + 1);
+  const where = `${opts.ssh ?? 'this machine'} localhost:${port}`;
+  let registry: RegistryRead | null = null;
+  if (opts.registry !== false) {
+    registry = /^[1-9][0-9]{0,4}$/u.test(port) && Number(port) <= 65535
+      ? (deps.readRegistry ?? readRegistryTags)({ port, ...(opts.ssh ? { sshHost: opts.ssh } : {}) })
+      : { ok: false, reason: `invalid registry port: ${registryAddr}` };
+  }
+  const tags = registry?.ok ? registry.tags : null;
+  const rows = foldImageLedger(ledger.events, tags);
+  const result: ImageLsResult = {
+    ledger: { path: ledger.path, exists: ledger.exists, events: ledger.events.length, unreadableLines: ledger.unreadableLines },
+    registry: registry === null
+      ? { read: false, where, tags: null, reason: 'skipped (--no-registry)' }
+      : registry.ok ? { read: true, where, tags: registry.tags.length } : { read: false, where, tags: null, reason: registry.reason },
+    rows,
+    counts: {
+      baseline: rows.filter((r) => r.current).length,
+      transient: tags === null ? null : rows.filter((r) => r.unledgered).length,
+      ledgered: rows.filter((r) => !r.unledgered).length,
+    },
+  };
+  try { debug.log('image.ledger', 'ls', { ledgerEvents: result.ledger.events, unreadableLines: result.ledger.unreadableLines, registryRead: result.registry.read, registryTags: result.registry.tags, transient: result.counts.transient }); } catch { /* log sink optional */ }
+  if (opts.json) { out(JSON.stringify(result, null, 2)); return result; }
+  out(`image ledger · ${ledger.path}${ledger.exists ? '' : ' (no ledger yet)'} · events ${ledger.events.length}${ledger.unreadableLines ? ` · ⚠️ unreadable lines ${ledger.unreadableLines}` : ''}`);
+  out(result.registry.read
+    ? `registry · ${where} · tags ${result.registry.tags}`
+    : `registry · ${where} · ⚠️ not read — ${result.registry.reason} (transient count unknown, not 0)`);
+  for (const r of rows.filter((x) => !x.unledgered)) {
+    const reg = r.inRegistry === null ? '?' : r.inRegistry ? 'reg' : '⚠️ not-in-registry';
+    out(`  ${r.tag}  ${r.role}${r.role === 'baseline' ? (r.current ? '*' : ' (previous)') : ''}  keep=${r.keep}  ${r.origin ? `${r.origin.reason}@${r.origin.host}` : '-'}  ${r.lastTs}  ${reg}`);
+  }
+  const transient = rows.filter((x) => x.unledgered);
+  if (transient.length > 0) out(`  transient (registry tags without a ledger row) · ${transient.length} · ${transient.slice(0, 8).map((r) => r.tag).join(' ')}${transient.length > 8 ? ' …' : ''}`);
+  out(`baseline ${result.counts.baseline} · ledgered ${result.counts.ledgered} · transient ${result.counts.transient ?? 'unknown'}`);
+  return result;
+}
+
+/**
+ * Recording site: `config set harness.imageCommit <commit>` (the rail pins the baseline through it).
+ * Appends a `baseline ⊕ pin` event (none when that tag is already the current baseline). A failed ledger write never fails the config write; it warns
+ * and leaves an observation.
+ */
+export function recordImagePinFromConfigSet(path: string, value: unknown, deps: { ledgerPath?: string; warn?: (msg: string) => void; now?: () => Date; host?: string } = {}): 'recorded' | 'unchanged' | 'skipped' | 'failed' {
+  if (path !== 'harness.imageCommit' || !isPodImageCommit(value)) return 'skipped';
+  const ledgerPath = deps.ledgerPath ?? imageLedgerPath();
+  try {
+    // The rail re-pins the same commit on quiet cycles — one event per baseline change, not per call.
+    const current = foldImageLedger(readImageLedger(ledgerPath).events, null).find((r) => r.current);
+    if (current && current.tag === value.trim().toLowerCase().slice(0, 12)) return 'unchanged';
+    const event = baselinePinEvent(value, { ...(deps.now ? { now: deps.now } : {}), ...(deps.host ? { host: deps.host } : {}) });
+    appendImageLedgerEvent(event, ledgerPath);
+    try { debug.log('image.ledger', 'baseline-pinned', { tag: event.tag, commit: event.commit, reason: event.origin.reason, host: event.origin.host, ledgerPath }); } catch { /* */ }
+    return 'recorded';
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    try { debug.log('image.ledger', 'baseline-pin-record-failed', { error: message, ledgerPath }); } catch { /* */ }
+    (deps.warn ?? ((m: string) => console.error(m)))(`⚠️ image ledger: baseline pin was set in config but not recorded in ${ledgerPath} — ${message}`);
+    return 'failed';
+  }
+}
+
+export function registerImageCommands(program: Command): void {
+  const image = program.command('image').description('하니스 이미지 원장 — 신분 표지(역할·보존·출신) · 원장 없는 레지스트리 태그 = transient');
+  image.command('ls')
+    .description('원장 행 ⊕ 레지스트리 태그(원장에 없으면 transient) — 읽기 전용')
+    .option('--json', 'JSON 출력')
+    .option('--ssh <host>', '레지스트리가 있는 노드(그 노드의 localhost 포트로 조회)')
+    .option('--no-registry', '레지스트리를 읽지 않는다(원장만)')
+    .action((opts: { json?: boolean; ssh?: string; registry?: boolean }) => { imageLs(opts); });
+}

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/log-event-names.ts

@@ -121,7 +121,9 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "background-drain",
   "background-finish",
   "barge.in",
+  "base-ensured",
   "base-preexisting",
+  "base-refused",
   "base-selection",
   "base.default-branch",
   "base.remote-unreachable",
@@ -736,6 +738,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "launch-overrides",
   "layered-load",
   "ledger",
+  "ledger-unwritten",
   "ledger-write-failed",
   "legacy-codex-invoked",
   "legacy-finalize",
@@ -773,6 +776,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "luna-failed",
   "luna-no-allowlist",
   "made-public",
+  "main-sync-skipped",
   "main-tree-reject",
   "malformed-tail",
   "manifest-frame-fail",

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/pr-cli.ts

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { basename, join, relative, resolve } from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { createInterface } from 'node:readline';
 import type { Command } from 'commander';
 import {
@@ -57,7 +57,8 @@ import { branchLineageSlug, findSiblingPrs } from './pr-lineage.js';
 import { parseReleaseNoteSection } from '../release-loop/release-note.js';
 import { landingFreezeMessage } from '../release-loop/landing-freeze.js';
 import { admitLandingMerge } from '../self-implement/frozen-merges.js';
-import { verifyOverlapEvidence } from './pr-land-overlap-evidence.js';
+import { verifyAncestorAutoPass, verifyOverlapEvidence } from './pr-land-overlap-evidence.js';
+import { taskAgentStatePath } from '../task-agent/task-hand.js';
 import { enqueueL8ShadowQueue, runL8ShadowQueue, shadowPrNumber, statusL8ShadowQueue, type L8ShadowQueueDeps } from '../self-implement/l8-merge-queue.js';
 
 export { branchLineageSlug, findSiblingPrs };
@@ -107,6 +108,8 @@ export interface PrLandDeps {
   resolveBase?: (run: CmdRunner, cwd: string, explicit?: string) => string | undefined;
   currentBranch?: (cwd: string) => string | undefined;
   readFile?: (path: string) => string;
+  /** 증거 파일 없는 already-ancestor 자동 판정이 리뷰 결과를 찾는 자리(기본 `<TA 상태 디렉터리>/review-results`). */
+  reviewResultsDir?: string;
   listUnfinishedRuns?: () => FederatedUnfinishedRunLedgerQuery | readonly FederatedUnfinishedRunLedgerEntry[];
   queryRunningRuns?: () => RunningRunsResult;
   listOpenPrs?: () => readonly { number: number; headRefName: string }[] | null;
@@ -1038,6 +1041,8 @@ const SOURCE_SPLIT_PR_LIST_LIMIT = 200;
  */
 const MERGED_PR_LOOKUP_RUNAWAY_CAP = 1000;
 const SOURCE_LOOKUP_FAILED_LINE = '⚠ source: 브랜치 조회에 실패해 갈래를 내지 못했습니다.';
+/** BENCH-ISOLATED-ARMS — 벤치 팔 PR 라벨(착지 금지). */
+export const BENCH_LABEL = 'elanous:bench';
 
 type MergedPrHeadRefsLookup = {
   map: Map<number, string>;
@@ -1616,9 +1621,23 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     if (verdict.ok) {
       out.log(verdict.mode === 'already-ancestor'
         ? `✓ overlap-evidence: already-ancestor — 겹친 최근 착지 ${overlappingLandings.length}개가 전부 head ${opts.expectedHead!.slice(0, 12)} 의 조상 · review pass must-fix 0 (${verdict.reviewResult})`
-        : `✓ overlap-evidence: ${ref.remote}/${ref.branch} ${verdict.baseTip.slice(0, 12)} ⊂ head ${opts.expectedHead!.slice(0, 12)} · gate passed on that base · review pass must-fix 0 (${verdict.reviewResult})`);
+        : verdict.mode === 'base-advanced-disjoint'
+          ? `✓ overlap-evidence: base-advanced-disjoint — gate base ${verdict.gateBase.slice(0, 12)} ⊂ head ${opts.expectedHead!.slice(0, 12)} · ${ref.remote}/${ref.branch} ${verdict.baseTip.slice(0, 12)} 까지 ${verdict.windowCommits}개 커밋이 PR 파일을 안 건드린다 · review pass|warn must-fix 0 (${verdict.reviewResult})`
+          : `✓ overlap-evidence: ${ref.remote}/${ref.branch} ${verdict.baseTip.slice(0, 12)} ⊂ head ${opts.expectedHead!.slice(0, 12)} · gate passed on that base · review pass must-fix 0 (${verdict.reviewResult})`);
     }
     else out.error(`✗ overlap-evidence: ${verdict.reason}`);
+  } else if (pinned && overlapDecision?.outcome === 'unavailable') {
+    // 증거 파일이 없을 때 — 겹친 착지가 전부 머리의 조상이고 표준 자리의 리뷰가 pass|warn ⊕ must-fix 0 이면 통과(아니면 종전 거부).
+    const verdict = verifyAncestorAutoPass({
+      pr: Number(opts.pr), expectedHead: opts.expectedHead!, cwd, run, readFile, overlappingLandings,
+      reviewResultsDir: deps.reviewResultsDir ?? join(dirname(taskAgentStatePath()), 'review-results'),
+      listDir: (dir) => readdirSync(dir),
+    });
+    overlapEvidenceAccepted = verdict.ok;
+    if (verdict.ok) {
+      out.log(`✓ overlap-evidence: already-ancestor-auto — 겹친 최근 착지 ${overlappingLandings.length}개가 전부 head ${opts.expectedHead!.slice(0, 12)} 의 조상 · review pass|warn must-fix 0 (${verdict.reviewResult})`);
+    }
+    else out.error(`✗ ancestor-auto: ${verdict.reason}`);
   }
   if (pinned && overlapDecision && overlapDecision.outcome !== 'user-merge' && !overlapEvidenceAccepted) {
     out.error('✗ expected-head: overlap merge approval unavailable for the reviewed head');
@@ -1695,6 +1714,37 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     }
   }
 
+  // LAND-BASE-GUARD-ORDER — 재사용할 PR 의 base·라벨은 upsert «전에» 본다(10-11 #26150: upsert 가 base 를 main 으로
+  //   바꾼 뒤에 읽어 #26117 base-guard 가 무력 · 거부돼도 PR 이 바뀌어 남았다). 거부는 PR 을 건드리지 않는다.
+  // LAND-BASE-MAIN-GUARD — 재사용한 PR 의 base 가 기본 가지가 아니면 병합 «전에» 거부한다(10-11 #26022 가 bench/base-night-* 로 병합됨).
+  //   명시 --base 를 준 경우만 통과한다. 못 읽은 base 는 종전 흐름대로 둔다(병합 뒤 되읽기).
+  // BENCH-ISOLATED-ARMS — `elanous:bench` 라벨 PR 은 벤치 팔 산출이라 착지하지 않는다(승자는 주인이 main 위로 따로 수확).
+  //   명시 --base 로도 통과하지 않는다. 못 읽은 라벨은 base-guard 와 같이 종전 흐름대로 둔다.
+  const refuseReusedPr = (url: string): number | undefined => {
+    const reusedNumber = /\/(\d+)$/.exec(url)?.[1] ?? url;
+    if (!opts.base?.trim()) {
+      const reusedBase = run('gh', ['pr', 'view', url, '--json', 'baseRefName', '--jq', '.baseRefName'], { cwd });
+      const reusedBaseName = reusedBase.ok ? reusedBase.out.trim() : '';
+      if (reusedBaseName && reusedBaseName !== baseBranchName) {
+        record('base-guard', false, { url, prBase: reusedBaseName, expected: baseBranchName });
+        out.error(`✗ base-guard: base=${reusedBaseName} ≠ ${baseBranchName} · gh pr edit ${reusedNumber} --base ${baseBranchName} 뒤 다시`);
+        return 1;
+      }
+    }
+    const reusedLabels = run('gh', ['pr', 'view', url, '--json', 'labels', '--jq', '.labels[].name'], { cwd });
+    if (reusedLabels.ok && reusedLabels.out.split('\n').some((name) => name.trim() === BENCH_LABEL)) {
+      record('bench-guard', false, { url, label: BENCH_LABEL });
+      out.error(`✗ bench-guard: #${reusedNumber} 은 ${BENCH_LABEL} 벤치 팔 PR 이라 착지하지 않는다 · 승자 diff 를 main 위 새 가지로 옮겨 착지`);
+      return 1;
+    }
+    return undefined;
+  };
+  const guardedBeforeUpsert = !hold && !!existing.url;
+  if (guardedBeforeUpsert) {
+    const refused = refuseReusedPr(existing.url!);
+    if (refused !== undefined) return refused;
+  }
+
   // A pinned, already-reviewed commit must not go through upsertPr (git add/commit/force-push/PR edit).
   const upsert = pinned
     ? existing.status === 'ok OUTPUT' && existing.url === pinnedUrl
@@ -1703,7 +1753,8 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     : manager.upsertPr({
     branch,
     worktreePath: cwd,
-    base,
+    // 기존 PR 재사용이면 명시 --base 일 때만 넘긴다 — 추론한 base 는 PR 을 main 으로 재타기팅한다(#26150).
+    ...(opts.base?.trim() || !existing.url ? { base } : {}),
     draft: hold,
     title: title ?? `Land ${branch}`,
     // ⛔⭐ 본문 기본값도 «내용이 있는» 쪽으로 — 종전 34자 플레이스홀더는 ***아무에게도 쓸모가 없었고***
@@ -1741,6 +1792,12 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     return 0;
   }
 
+  // 착지 전 PR 을 못 찾았는데(조회 실패) upsert 가 기존 PR 을 재사용했다면 여기서 한 번 더 본다.
+  if (upsert.reused && !guardedBeforeUpsert) {
+    const refused = refuseReusedPr(upsert.url);
+    if (refused !== undefined) return refused;
+  }
+
   const prNumber = Number(/\/(\d+)$/.exec(upsert.url)?.[1]);
   const landedHead = run('git', ['rev-parse', 'HEAD'], { cwd });
   const headCommit = landedHead.ok && /^[a-f0-9]{40}$/i.test(landedHead.out.trim()) ? landedHead.out.trim() : undefined;