elanous 0.2.31 → 0.2.34

package/src/harness/harness-pod-dispatch.ts

@@ -58,11 +58,41 @@ export interface HarnessPodDispatchInput {
   readonly authorGradeSource?: import('../self-implement/goal-author.js').GoalAuthorGradeSource;
 }
 
+/** The mbp fleet alias must select the installed local k3d context, with a deliberately small first capacity. */
+export function resolveHarnessPodPool(spec: string | undefined): string | undefined {
+  if (!spec) return spec;
+  let changed = false;
+  let mbpCapacity = 0;
+  let mbpMembers = 0;
+  const members = spec.split(',').map((raw) => {
+    const part = raw.trim();
+    const alias = /^pool-mbp@mbp:(\d+)$/.exec(part);
+    const local = /^k3d-monad-h1:(\d+)$/.exec(part);
+    if (!alias && !local) {
+      if (/^pool-mbp@mbp(?::|$)/.test(part) || /^k3d-monad-h1(?::|$)/.test(part)) {
+        throw new Error(`mbp Pod 풀 스펙 오류: ${part}`);
+      }
+      return part;
+    }
+    const capacity = Number((alias ?? local)![1]);
+    if (!Number.isInteger(capacity) || capacity < 1 || capacity > 2) {
+      throw new Error(`mbp Pod 풀 상한은 1~2: ${part}`);
+    }
+    mbpCapacity += capacity;
+    mbpMembers++;
+    if (mbpCapacity > 2) throw new Error(`mbp Pod 풀 합산 상한은 2: ${spec}`);
+    if (mbpMembers > 1) throw new Error(`mbp Pod 풀 컨텍스트 중복: ${spec}`);
+    if (alias) changed = true;
+    return `k3d-monad-h1:${capacity}`;
+  });
+  return changed ? members.join(',') : spec;
+}
+
 export function podOrchestrateArgs(input: HarnessPodDispatchInput, goalFile: string): string[] {
   return [
     ELANOUS_ENTRY_SCRIPT, 'self', 'orchestrate', '--goal-file', goalFile,
     '--substrate', 'pod',
-    ...(input.podPool ? ['--pod-pool', input.podPool] : []),
+    ...(input.podPool ? ['--pod-pool', resolveHarnessPodPool(input.podPool)!] : []),
     // 하니스 기본(자동 병합)을 따른다 · 끄면 PR 까지 — 어느 쪽이든 Pod 가 사라져도 결과가 남는다.
     ...(input.repairCommitOnly ? [] : input.autoMerge === false ? ['--open-pr'] : ['--auto-merge']),
     ...(input.repairCommitOnly && input.source ? ['--base', `pr-${input.source.slice(3)}`] : input.base ? ['--base', input.base] : []),
@@ -99,6 +129,13 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps?: PodDispatchDeps): number | Promise<number>;
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDispatchDeps = {}): number | Promise<number> {
   const cwd = deps.cwd ?? process.cwd();
+  try { resolveHarnessPodPool(input.podPool); }
+  catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('harness.substrate', 'pod-pool-refused', { entrance: input.entrance, reason });
+    console.error(reason);
+    return 2;
+  }
   if (input.source !== undefined) {
     try {
       parsePodSourceSpec(input.source);

package/src/harness/harness-queue.ts

@@ -21,6 +21,7 @@ import { hostLeaseCounts, leaseHasPendingPod } from '../pod-lease/host-lease.js'
 import { leaseKubectl, measurePoolLease } from '../task-orchestrator/surfaces/pod-lease.js';
 import { parsePodPool, podPoolHostLease, resolvePodPoolSpec } from '../task-orchestrator/surfaces/pod-pool.js';
 import { writeHarnessQueueReceipt } from './harness-queue-child.js';
+import { detectReleaseGateActive, gateReserve } from './gate-reserve.js';
 import { adviseLaunch, compareLaunchAdvice, type LaunchAdvice } from './launch-advice.js';
 import { finishAdvice, measureFinish, recordFinishHistory, type FinishMetrics } from '../loops/orchestrator/finish-rate.js';
 import { collectDraftMetrics, DRAFT_NEEDS_OWNER_SEAT_CAP, shouldHoldSeatNewLaunch, type DraftMetrics } from '../self-dev/draft-sweep.js';
@@ -85,6 +86,8 @@ export interface HarnessQueueDeps {
   pool?: () => QueuePool;
   /** Shadow-only advice seam; exceptions must not affect the queue decision. */
   advice?: typeof adviseLaunch;
+  /** Gate-reserve observation only; never changes seatCapDetails or decideSpawn inputs. */
+  releaseGateActive?: () => boolean | Promise<boolean>;
   launch?: (item: QueueItem, args: string[], root: string) => Promise<number>;
   /** Test seam: runs after a direct CLI call enqueued its row and before that call's own tick (race tests). */
   afterEnqueue?: (item: QueueItem) => void | Promise<void>;
@@ -1495,6 +1498,10 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
       }
       return waiting();
     }
+    // Shadow measurement runs outside the approval path. One async probe serves all candidates in this tick.
+    const gateActivePromise = !childUniverses?.unreadable.length
+      ? Promise.resolve().then(() => (deps.releaseGateActive ?? detectReleaseGateActive)()).catch(() => false)
+      : undefined;
     // NEEDS-OWNER-CENSUS: one draft census per tick, shared by every candidate. A full census pages all
     // open drafts, the 48h closed cohort, and one claim-comment gh call per open draft — re-running it
     // per candidate multiplied those calls by the seat count and raced the rate limit the seat-loop tick
@@ -1516,6 +1523,14 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
       const injectedCap = deps.cap?.(item.seat);
       const details = seatCapDetails({ seat: item.seat, caps, gate, injectedCap });
       const active = seatActive(item.seat);
+      // An unreadable child universe makes the running count incomplete; do not emit a misleading cap sample.
+      if (gateActivePromise) void gateActivePromise.then((gateActive) => {
+        try {
+          const reserve = gateReserve({ releaseGateActive: gateActive === true, seat: item.seat, configuredGateCap: gate?.[item.seat] ?? 4 });
+          debug.log('harness.queue', 'gate-reserve-shadow', { seat: item.seat, active: reserve.active, wouldCap: reserve.wouldCap,
+            cap: details.cap, running: active });
+        } catch { /* Shadow observation cannot affect the decision. */ }
+      });
       if (active >= details.cap) { blocked.set(item.seat, { reason: seatLine(item.seat, active, details), active }); continue; }
       if (!pool && !poolReason) {
         try { pool = (deps.pool ?? readHarnessQueuePool)(); }

package/src/harness/harness-salvage-cli.ts

@@ -5,7 +5,9 @@
 import type { Command } from 'commander';
 import { debug } from '../debug/log.js';
 import { normalizeRunId } from './harness-space.js';
-import { loadFederatedRunLedger } from '../self-implement/run-ledger.js';
+import { loadFederatedRunLedger, loadRunLedger } from '../self-implement/run-ledger.js';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import { remoteLedgerMirrorDirs } from '../task-agent/parent-host.js';
 import { getUserConfig } from '../user-config.js';
 import { resolveRepositoryName } from './repository-name.js';
 import {
@@ -35,9 +37,19 @@ export interface HarnessSalvageDeps {
   print?: (line: string) => void;
 }
 
+/** 원격 부모 거울 원장 — remoteLedgerMirrorDirs(prodInstanceRoot()) 를 로컬·연합 원장 «뒤에»만 붙인다(tasks 쪽 원장 조회와 같은 재사용 경로 · 거울 생성·SSH 는 별개 칸). */
+function loadMirroredRunLedger(runId: string): ReturnType<typeof loadRunLedger> {
+  for (const directory of remoteLedgerMirrorDirs(prodInstanceRoot())) {
+    const ledger = loadRunLedger(runId, directory);
+    if (ledger !== null) return ledger;
+  }
+  return null;
+}
+
 function defaultReadPr(runId: string): RunPrState {
   try {
-    return prStateFromLedger(loadFederatedRunLedger(runId, { includeTest: true }));
+    // 로컬·연합 원장 먼저, 없으면 원격 부모 거울 — 순서는 tasks 쪽 원장 조회와 같다.
+    return prStateFromLedger(loadFederatedRunLedger(runId, { includeTest: true }) ?? loadMirroredRunLedger(runId));
   } catch (error) {
     return { status: 'unknown', reason: `원장 읽기 실패 · ${error instanceof Error ? error.message : String(error)}` };
   }

package/src/index.ts

@@ -44,7 +44,6 @@ import { applyTestFlagFromArgv, observeTestFlagOwnership, uncoveredTestFlagPaths
 import { registerPtyTakeoverCommands } from './cli/pty-takeover-cli.js';
 import { registerPtyRecordCommand } from './cli/pty-record-cli.js';
 import { registerLeaderCommands } from './cli/leader-cli.js';
-import { registerPrCommands } from './cli/pr-cli.js';
 import { registerRepoCommands } from './cli/repo-cli.js';
 import { registerAgentCommands, runChatTurnCli, emitDetachedProgress } from './cli/agent-cli.js';
 export { runChatTurnCli, buildCliAgentTools, setCliAgentDispatchForTesting, emitDetachedProgress, emitHarnessFeedbackProgress } from './cli/agent-cli.js';
@@ -916,7 +915,114 @@ async function runDevSayFromWords(
 
 registerPtyTakeoverCommands(program);
 registerPtyRecordCommand(program.commands.find((command) => command.name() === 'pty')!);
-registerPrCommands(program);
+// Keep the public PR help slot but defer its large CI/landing import graph
+// until the PR command is actually selected (including direct Commander use).
+const prCommandOrder = program.commands.length;
+const prShell = program.command('pr').description('PR landing commands');
+// The exported Commander tree is also the public entrance inventory. Keep its
+// lightweight declarations visible without importing the CI/landing graph.
+prShell.command('supersede-drafts').description('확인된 병합 PR의 명시 Supersedes 같은 칸 draft만 정리')
+  .requiredOption('--pr <number>', '병합 PR 번호')
+  .option('--cwd <path>', '저장소 경로');
+prShell.command('census').description('열린 PR 전체·골 문서만·2일 무커밋 draft·미닫힌 superseded 집계').option('--cwd <path>', '저장소 경로');
+prShell.command('open-guard').description('새 PR 전에 같은 파일 OPEN PR·골 문서만·자리별 상한 검사')
+  .option('--cwd <path>', '작업 트리 경로').option('--base <ref>', '비교 base ref', 'origin/main')
+  .option('--seat <seat>', 'PR 소유 자리(OP|TC|MK|UX)').option('--cell <id>', '릴리스 칸 id (같은 칸 OPEN PR 검사)')
+  .option('--seat-cap <number>', '자리별 열린 PR 경고 상한', '30');
+const prQueueShell = prShell.command('queue').description('Shadow merge queue (never lands PRs)');
+prQueueShell.command('status').description('Show pending PRs and shadow verdicts');
+prQueueShell.command('enqueue <pr>').description('Pin a ready PR at the tail of the shadow queue');
+prQueueShell.command('run').description('Evaluate the first PR without merging').requiredOption('--shadow', 'Only evaluate; never land');
+prShell.command('land').description('현재 브랜치 PR을 생성 또는 갱신해 ready 상태로 만들고 squash merge')
+  .option('--base <branch>', 'PR base branch').option('--cwd <path>', '작업 트리 경로')
+  .option('--pr <number>', '기존 PR 번호 고정 (--expected-head 와 함께)')
+  .option('--expected-head <sha>', '리뷰된 PR 머리 SHA 고정 (--pr 와 함께)')
+  .option('--heavy-remote', '머리 고정 착지의 무거운 게이트를 node-b·node-c 중 빈 호스트에서 실행; head⊕main 증거가 없거나 실패하면 거부(로컬 폴백 없음)')
+  .option('--heavy-on-pod-shadow', '--heavy-remote 판정을 유지하고 같은 head/main의 Pod 타입·변경 시험 결과를 비교만 한다')
+  .option('--dry-run', '변경 없이 landing 계획만 출력').option('--hold', 'PR을 생성 또는 갱신한 뒤 병합하지 않고 쌓아 둔다')
+  .option('--title <title>', 'PR title').option('--title-file <path>', 'PR title file')
+  .option('--body <body>', 'PR body').option('--body-file <path>', 'PR body file')
+  .option('--commit-message <message>', 'upsert commit message')
+  .option('--commit-message-file <path>', 'upsert commit message file (takes precedence over --commit-message)')
+  .option('--include-active-run-files', '도는 런 파일을 이번 착지에 포함 (기본 동작)')
+  .option('--exclude-active-run-files', '도는 런과 겹친 파일을 이번 착지에서 제외')
+  .option('--exclude-active-run-sources', '⚠ 위험: --exclude-active-run-files 가 골 문서가 아닌 파일(소스)을 빼도 착지를 강행')
+  .option('--land-reason <text>', '권고를 보고도 지금 내는 이유(예: 남이 기다리는 차단 해제)')
+  .option('--force-freeze <reason>', '동결을 넘겨 병합할 명시적 이유(필수)')
+  .option('--allow-public-leak', '바뀐 파일이 공개본에 사적 흔적을 실어도 착지(이유는 --land-reason)')
+  .option('--overlap-evidence <file>', '머리 고정 착지 전용: 비대화형 겹침 승인을 대신할 증거 JSON {pr, head, gate:{head,baseCommit,passed}, reviewResult} — 재기반·재게이트·리뷰를 CLI 가 다시 잰다(겹친 착지가 전부 머리의 조상이면 리뷰만 · gate 생략 가능)');
+prShell.command('granularity').description('로컬 git log 로 최근 착지 단위(파일 중복·단일 파일 비율)를 센다')
+  .option('--since <window>', 'git log --since 창', '1 day ago')
+  .option('--cwd <path>', '작업 트리 경로').option('--base <branch>', '착지 집계에 쓸 base 브랜치')
+  .option('--with-source', 'PR 번호로 브랜치를 조회해 하니스↔사람 갈래를 함께 낸다 (gh 필요)');
+const parseBeforePrRegistration = program.parse.bind(program);
+const parseAsyncBeforePrRegistration = program.parseAsync.bind(program);
+let prRegistered = false;
+function ensurePrRegistered(): void {
+  if (prRegistered) return;
+  const { registerPrCommands } = require('./cli/pr-cli.js') as typeof import('./cli/pr-cli.js');
+  // Commander exposes this array as readonly in types, while registration still mutates it at runtime.
+  const commands = program.commands as Command[];
+  commands.splice(prCommandOrder, 1);
+  registerPrCommands(program);
+  const registered = commands.pop()!;
+  commands.splice(prCommandOrder, 0, registered);
+  prRegistered = true;
+}
+// Consumers may hold a reference to the exported PR subtree and parse that
+// command directly, bypassing program.parse. Keep those references executable
+// without loading the PR registrar until a direct parse actually occurs.
+function deferPrSubtreeParse(shell: Command, path: number[] = []): void {
+  const selected = () => {
+    ensurePrRegistered();
+    let command = program.commands[prCommandOrder]!;
+    for (const index of path) command = command.commands[index]!;
+    return command;
+  };
+  shell.parse = (...args: Parameters<Command['parse']>) => selected().parse(...args);
+  shell.parseAsync = (...args: Parameters<Command['parseAsync']>) => selected().parseAsync(...args);
+  shell.commands.forEach((child, index) => deferPrSubtreeParse(child, [...path, index]));
+}
+deferPrSubtreeParse(prShell);
+function selectedRootArgs(argv: readonly string[] | undefined, from?: string): { command: string | undefined; next: string | undefined; rootHelp: boolean } {
+  const args = (argv ?? process.argv).slice(from === 'user' ? 0 : from === 'electron' ? 1 : 2);
+  // parseOptions() emits Commander option events, so do not run it before the
+  // real parse. Only inspect leading root options; a subcommand owns the rest.
+  let position = 0;
+  let rootHelp = args.length === 0;
+  while (position < args.length) {
+    const token = args[position];
+    if (token === '--') { position++; break; }
+    if (token === '--help' || token === '-h' || token === '--help-all') {
+      rootHelp = true;
+      position++;
+      continue;
+    }
+    const option = program.options.find((item) => token === item.long || token === item.short
+      || (item.long && token.startsWith(`${item.long}=`)));
+    if (!option) {
+      if (token.startsWith('-')) { position++; continue; }
+      break;
+    }
+    position++;
+    if (option.required && !token.includes('=')) position++;
+    else if (option.optional && position < args.length && !args[position].startsWith('-')) position++;
+  }
+  return { command: args[position], next: args[position + 1], rootHelp };
+}
+function prSelectedForParse(argv: readonly string[] | undefined, from?: string): boolean {
+  const { command, next, rootHelp } = selectedRootArgs(argv, from);
+  return command === 'pr' || (command === 'help' && (!next || next === 'pr'))
+    || (!command && rootHelp);
+}
+program.parse = (...args: Parameters<typeof program.parse>) => {
+  if (prSelectedForParse(args[0], args[1]?.from)) ensurePrRegistered();
+  return parseBeforePrRegistration(...args);
+};
+program.parseAsync = (...args: Parameters<typeof program.parseAsync>) => {
+  if (prSelectedForParse(args[0], args[1]?.from)) ensurePrRegistered();
+  return parseAsyncBeforePrRegistration(...args);
+};
 registerRepoCommands(program);
 registerRoleCommands(program);
 registerMachineCommands(program);
@@ -4370,7 +4476,7 @@ selfCmd
       }
     };
     try {
-      const { dispatchHeavyCheck } = await import('./self-implement/gate-remote.js');
+      const { dispatchHeavyCheck, remoteSelfGateArgv } = await import('./self-implement/gate-remote.js');
       const { runGitCommand } = await import('./git-fs/runner.js');
       const topLevel = runGitCommand(process.cwd(), ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
       if (topLevel.status !== 0) throw new Error(`git rev-parse --show-toplevel failed: ${topLevel.stderr.trim() || `rc=${topLevel.status}`}`);
@@ -4389,13 +4495,13 @@ selfCmd
         const { remoteCommitSupportsArtifactDir, newRemoteArtifactDir } = await import('./self-implement/gate-artifacts.js');
         remoteArtifacts = remoteCommitSupportsArtifactDir(repo) ? { dir: newRemoteArtifactDir() } : { unsupported: true };
       }
-      const remoteArtifactArgs = remoteArtifacts && 'dir' in remoteArtifacts ? ['--artifact-dir', remoteArtifacts.dir] : [];
       // origin/main is pinned to this machine's origin/main on the host; any other base is passed as its resolved sha.
-      const remoteArgv = (sha: (ref: string) => string) => ['bun', 'bin/elanous.mjs', 'self', 'gate', '--local', ...(opts.changed ? ['--changed'] : []),
-        ...(opts.base ? ['--base', opts.base === 'origin/main' ? opts.base : sha(opts.base)] : []), ...(shards !== undefined ? ['--shards', String(shards)] : []),
+      const remoteArgv = (sha: (ref: string) => string) => remoteSelfGateArgv({
+        changed: opts.changed, base: opts.base, shards, fixedShardDistribution: opts.fixedShardDistribution,
+        includeImporters: opts.includeImporters,
         // A measured commit without this option rejects it (exit ≠ 0) — read as not passed, never as a silent measured run.
-        ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []),
-        ...(opts.includeImporters ? ['--include-importers'] : []), ...remoteArtifactArgs];
+        artifactDir: remoteArtifacts && 'dir' in remoteArtifacts ? remoteArtifacts.dir : undefined,
+      }, sha);
       const { gateHostReservationRoot } = await import('./release-loop/gate-host-reservation.js');
       process.exitCode = await dispatchHeavyCheck({
         tool: 'self-gate', repo, installPwa: true, remoteArgv, refs: opts.base ? [opts.base] : [], reservationRoot: gateHostReservationRoot(),
@@ -4940,6 +5046,22 @@ const selfOrchestrateCmd = selfCmd
         const grokKeyNames = ['XAI_API_KEY', 'GROK_API_KEY', 'GROK_CODE_XAI_API_KEY'];
         // 명시 계정은 사람의 선택 — 공급자 폴백과 계정 브로커를 우회한다.
         const explicitPodAccount = (opts as { podAccount?: string }).podAccount;
+        const ownerMirrorAccount = process.env.ELANOUS_REMOTE_CODEX_ACCOUNT?.trim();
+        const childProvider = opts as { childLlmProvider?: string };
+        const requestedChildProvider = childProvider.childLlmProvider?.trim();
+        if (ownerMirrorAccount && explicitPodAccount && explicitPodAccount !== ownerMirrorAccount) {
+          ui.error(`pod: HQ 미러 계정은 ${ownerMirrorAccount} 인데 --pod-account ${explicitPodAccount} 을 사용할 수 없다`);
+          process.exit(2);
+        }
+        if (ownerMirrorAccount && requestedChildProvider && requestedChildProvider !== 'openai-codex') {
+          const reason = `pod: HQ 미러 계정 ${ownerMirrorAccount} 은 openai-codex 전용이라 --child-llm-provider ${requestedChildProvider} 을 사용할 수 없다`;
+          ui.error(reason);
+          debug.log('self-implement.pod', 'child-provider-refused', { provider: requestedChildProvider, reason });
+          process.exit(2);
+        }
+        // An owner mirror pins the Pod child to that access-only Codex account; do not let a configured
+        // podChildDefault route the child to an unrelated provider.
+        if (ownerMirrorAccount && !requestedChildProvider) childProvider.childLlmProvider = 'openai-codex';
         let accountBroker: (() => string) | undefined;
         let rotationAccounts: readonly string[] | undefined;
         let podProvider: import('./task-orchestrator/surfaces/pod-child-providers.js').PodChildProvider = 'openai-codex';
@@ -5031,7 +5153,8 @@ const selfOrchestrateCmd = selfCmd
             }
           }
           // 10-05 PODPROVIDER: a launch that named the child provider gets it, or is refused — never a silent codex.
-          const namedChild = (opts as { childLlmProvider?: string }).childLlmProvider?.trim();
+          const explicitChild = (opts as { childLlmProvider?: string }).childLlmProvider?.trim();
+          const namedChild = ownerMirrorAccount && !explicitChild ? 'openai-codex' : explicitChild;
           const { podNamedChildProvider, podFallbackCredentials, podGrokSubscriptionUsable: namedGrokUsable } = await import('./task-orchestrator/surfaces/self-implement-pod.js');
           const { readFileSync: readPodKeyFile } = await import('node:fs');
           const { homedir: podHome } = await import('node:os');
@@ -5051,12 +5174,27 @@ const selfOrchestrateCmd = selfCmd
           if (namedChildDecision.refuse) { ui.error(namedChildDecision.refuse); debug.log('self-implement.pod', 'child-provider-refused', { provider: namedChild, reason: namedChildDecision.refuse }); process.exit(2); }
           // A named codex child must stay codex — the plan may not fall back to grok (post-review must-fix).
           const namedCodex = namedChildDecision.provider === 'openai-codex';
+          let planCandidates = inspectCodexRotation().candidates;
+          if (ownerMirrorAccount) {
+            const used = process.env.ELANOUS_REMOTE_CODEX_USED_PERCENT;
+            const parsedUsed = used && used !== 'unknown' ? Number(used) : undefined;
+            const threshold = Number(process.env.ELANOUS_REMOTE_CODEX_THRESHOLD_PERCENT);
+            if (!Number.isFinite(threshold) || threshold <= 0 || threshold > 100) {
+              ui.error('pod: HQ Codex 미러의 유효 임계 표지가 없어 발사를 거부한다');
+              process.exit(2);
+            }
+            const { ownerCodexMirrorCandidate } = await import('./task-orchestrator/surfaces/pod-account-broker.js');
+            planCandidates = ownerCodexMirrorCandidate(planCandidates, ownerMirrorAccount, parsedUsed !== undefined && Number.isFinite(parsedUsed) ? parsedUsed : undefined);
+            if (planCandidates.length === 0) { ui.error(`pod: HQ Codex 미러 계정 ${ownerMirrorAccount} 이 원격 auth-store 후보에 없다`); process.exit(2); }
+          }
           const plan: import('./task-orchestrator/surfaces/pod-account-broker.js').PodProviderPlan | null = namedChildDecision.provider === 'openrouter' || namedChildDecision.provider === 'anthropic' || namedChildDecision.provider === 'bedrock' || namedChildDecision.provider === 'glm' ? null : namedChildDecision.provider === 'grok'
             ? { provider: 'grok', excluded: [], grokSubscriptionEligible: credential?.kind === 'subscription' }
             : planPodProvider({
-            codexCandidates: inspectCodexRotation().candidates,
+            codexCandidates: planCandidates,
             // Per-account caps (대표 default:97) override the Pod default cap — without them default was dropped at 60%.
-            thresholdPercentByAccount: launchPolicy.llm?.codexAccountRotationThresholdPercentByAccount,
+            thresholdPercentByAccount: ownerMirrorAccount
+              ? { [ownerMirrorAccount]: Number(process.env.ELANOUS_REMOTE_CODEX_THRESHOLD_PERCENT) }
+              : launchPolicy.llm?.codexAccountRotationThresholdPercentByAccount,
             // 대표 한도 정책 한 값(`llm.codexQuotaPolicy`) — 크레딧·폴백을 같이 정한다.
             creditsAllowed: codexPolicyAllowsCredits(quotaPolicy),
             // SUBSCRIPTION-EXHAUST-REROUTE — 예비분 이하 잔액(«알려진» 값)의 계정은 크레딧으로 쓰지 않는다.
@@ -5759,7 +5897,8 @@ selfCmd
   .option('--context-text <text>', '리뷰어가 함께 판단할 텍스트(반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
   .option('--json', '구조화 출력 {pr, verdict, mustFix, shouldFix, reviewed}')
   .option('--save <name>', '리뷰 결과를 상태 디렉터리의 review-results/<name>-<PR>-<head12>.json에 저장')
-  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; json?: boolean; save?: string }) => {
+  .option('--over-cap-reason <reason>', '저장 리뷰 r5 상한 이후 이번 호출 1회 예외 사유(doctor.review cap-override 기록)')
+  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; json?: boolean; save?: string; overCapReason?: string }) => {
     const prArgs = prParts.flatMap((p) => String(p).split(/[,\s]+/).filter(Boolean)); // 번호/#번호/URL·콤마목록.
     if (!prArgs.length) { ui.error('PR 필요: elanous self review <번호|URL> [..]'); process.exit(2); }
     // ⭐ 본문은 seam(`runSelfReviewCliCommand`)에 있다 — 이 액션은 **의존 배선만** 한다.
@@ -5850,6 +5989,17 @@ selfCmd
       roleFallbackModel: () => (getOpenRouterApiKeyForReview()?.trim() ? ROLE_REVIEWER_FALLBACK_MODEL : undefined),
       registerSink: async (surface) => { await registerStandaloneLogSink(surface); },
       log: (event, data, o) => debug.log('self-review', event, data, o ?? {}),
+      observeDoctorReview: (event, data, o) => debug.log('doctor.review', event, data, o ?? {}),
+      loadDoctorReviewBrief: async ({ pr, head, title, body, changedFiles }) => {
+        // MK's doctor module is a separate PR. Until it lands, keep the original intent and record brief-unavailable.
+        const modulePath = './self-implement/review-round-brief.js';
+        const { effectiveInstanceRoot } = await import('./instance/resolve.js');
+        const doctor = await import(modulePath) as {
+          loadReviewRoundBrief(input: { pr: number; head: string; title: string; body: string; changedFiles: string[]; reviewResultsDir: string }): unknown;
+          renderReviewBriefIntentBlock(brief: unknown): string | null;
+        };
+        return doctor.renderReviewBriefIntentBlock(doctor.loadReviewRoundBrief({ pr, head, title, body, changedFiles, reviewResultsDir: _joinPath(effectiveInstanceRoot(), 'review-results') }));
+      },
       info: (t) => ui.info(t),
       error: (t) => ui.error(t),
       print: (t) => console.log(t),
@@ -6175,6 +6325,36 @@ async function loadJevAccessOrExit(): Promise<import('./decide/jev.js').JevAcces
 registerIntakeCommands(program);
 
 registerLogsCommands(program);
+// Keep the sim command in its public slot until either CLI or direct Commander
+// parsing selects it (or asks for help). The domain registrar owns its definition.
+const simCommandOrder = program.commands.length;
+program.command('sim').description('격리 시나리오를 실행하고 화면·로그 기대값을 대조한다');
+const parseWithRegisteredCommands = program.parse.bind(program);
+const parseAsyncWithRegisteredCommands = program.parseAsync.bind(program);
+let simRegistered = false;
+function ensureSimRegistered(): void {
+  if (simRegistered) return;
+  const { registerSimCommands } = require('./cli/sim-cli.js') as typeof import('./cli/sim-cli.js');
+  const commands = program.commands as Command[];
+  commands.splice(simCommandOrder, 1);
+  registerSimCommands(program);
+  const registered = commands.pop()!;
+  commands.splice(simCommandOrder, 0, registered);
+  simRegistered = true;
+}
+function simSelectedForParse(argv: readonly string[] | undefined, from?: string): boolean {
+  const { command, next, rootHelp } = selectedRootArgs(argv, from);
+  return command === 'sim' || (command === 'help' && next === 'sim')
+    || (!command && rootHelp);
+}
+program.parse = (...parseArgs: Parameters<typeof program.parse>) => {
+  if (simSelectedForParse(parseArgs[0], parseArgs[1]?.from)) ensureSimRegistered();
+  return parseWithRegisteredCommands(...parseArgs);
+};
+program.parseAsync = (...parseArgs: Parameters<typeof program.parseAsync>) => {
+  if (simSelectedForParse(parseArgs[0], parseArgs[1]?.from)) ensureSimRegistered();
+  return parseAsyncWithRegisteredCommands(...parseArgs);
+};
 
 // ── ad (marketing-ad pipeline entrance) ──
 /** ⛔ 「있다」와 「읽을 수 있는 파일이다」는 다른 값 — 디렉토리·권한 없는 파일을 실사로 읽지 않는다. */
@@ -11852,6 +12032,12 @@ async function main(): Promise<void> {
       return;
     }
     const showAll = args[0] === '--help-all';
+    if (firstCommand === 'sim' || (firstCommand === 'help' && args[1] === 'sim') || showAll || firstCommand === '--help' || firstCommand === '-h') {
+      await ensureSimRegistered();
+    }
+    // Maturity filtering mutates command visibility; register the final PR
+    // object before filtering so replacing the placeholder cannot reveal it.
+    if (prSelectedForParse(['node', 'elanous', ...args])) ensurePrRegistered();
     const role = getUserConfig().cli?.helpRole ?? 'owner';
     const { shown, hidden } = filterCliRootHelp(program.commands, role, showAll);
     debug.log('cli.maturity', 'help-filtered', { role, shown, hidden });

package/src/input/external-input-queue.ts

@@ -15,6 +15,11 @@
 //    - ⏹ 정확히 `/stop`·`/esc` 인 글(TUI-STOP-INPUT-BYPASS · #68): 대기열을 «건너뛰고» 지금 턴의 ESC 중단 경로
 //      (`requestStop` → 대시보드 escGate)를 바로 부른다. 대기 중인 일반 항목은 그대로·순서대로 남는다.
 //      턴이 없으면 아무것도 안 하고 `tui-stop-no-active-turn`(멈출 길이 없으면 `tui-stop-undelivered`)으로 던져 바깥 호출자(rc≠0)에게 알린다.
+//    - ⏹ 원시 pty 길(TUI-STOP-RAW-PTY): `pty text pty_<id> /stop --enter`·tmux 처럼 TUI 를 띄운 «PTY 자체»에 쓰면
+//      이 라우터를 안 지나 stdin 으로 들어오고, 턴 중 typeahead 가 «대기(응답 뒤)»에 쌓았다(10-17 재점검).
+//      ⇒ 턴 중 스트리밍 리스너가 stdin «한 청크»가 정확히 `/stop⏎`·`/esc⏎` 이면 `routeRawPtyStop` 으로 같은 `routeStop` 을 부른다.
+//      키보드는 한 키씩 오고 붙여넣기는 봉투에 싸이므로, 한 청크에 온 «글 한 줄 ⊕ Enter» 는 바깥 주입이다.
+//      턴 밖·Enter 없음·그 밖의 글은 종전대로 키로 흐른다(관측 `path: 'raw-pty'` · 제어 IPC 는 `'control-ipc'`).
 //
 // ⚠️ herdr/tmux 처럼 «터미널 자체»에 쓰는 길은 키보드와 구별할 수 없다 — 이 라우터는
 //    elanous 제어 IPC(`pty text`) 경로만 가른다.
@@ -40,11 +45,13 @@ export interface ExternalInputHost {
   requestStop?(): boolean;
   /** 외부 stop 의 결과 표지(채팅 로그 한 줄). */
   onExternalStop?(result: 'stopped' | 'no-turn' | 'failed'): void;
-  /** 대기열이 바뀌었다 — 화면 표지를 다시 그린다. */
-  onQueueChange?(pending: readonly ExternalInputItem[], event: 'queued' | 'delivered'): void;
+  /** 대기열의 현재 상태가 바뀌었다 — 화면 표지를 다시 그린다. */
+  onQueueChange?(pending: readonly ExternalInputItem[]): void;
 }
 
 export type ExternalInputRoute = 'passthrough' | 'submitted' | 'queued' | 'stopped';
+/** 외부 stop 이 들어온 길 — 제어 IPC(`tui:<pid>` · 이 라우터) / 원시 pty(stdin 한 청크). */
+export type ExternalStopPath = 'control-ipc' | 'raw-pty';
 export type ExternalInputDecision = 'passthrough' | 'submit-now' | 'queue' | 'reject';
 
 const EXTERNAL_INPUT_SOURCE: InputSourceRef = { kind: 'terminal', provider: 'pty' };
@@ -133,8 +140,8 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
   // 경고는 머리 항목 «하나»에 한 번 — 머리가 실제로 바뀔 때만 다시 경고할 수 있다(제출 실패로 남은 같은 머리는 유지).
   let staleTurnWarnedHead: ExternalInputItem | null = null;
 
-  const notify = (event: 'queued' | 'delivered'): void => {
-    try { host?.onQueueChange?.(pending, event); } catch { /* fail-soft — 표지 실패가 입력을 막지 않는다 */ }
+  const notify = (): void => {
+    try { host?.onQueueChange?.(pending); } catch { /* fail-soft — 표지 실패가 입력을 막지 않는다 */ }
   };
   const ensurePump = (): void => {
     if (pending.length > 0 && !stopPump) stopPump = schedule(pump, PUMP_MS);
@@ -163,20 +170,20 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
     if (!ok) { log('deliver-failed', { length: head.text.length, pending: pending.length }); return false; }
     pending = pending.slice(1);
     log('delivered', { length: head.text.length, waitedMs: now() - head.at, pending: pending.length });
-    notify('delivered');
+    notify();
     ensurePump();
     return true;
   }
 
   /** ⏹ 외부 stop — 대기열을 건너뛰고 지금 턴의 escGate 로. 대기열은 건드리지 않는다. */
-  function routeStop(h: ExternalInputHost, text: string): ExternalInputRoute {
+  function routeStop(h: ExternalInputHost, text: string, path: ExternalStopPath): ExternalInputRoute {
     let turnActive = false;
     try { turnActive = h.isTurnActive(); } catch { turnActive = false; }
     let stopped = false;
     if (turnActive && h.requestStop) {
       try { stopped = h.requestStop(); } catch { stopped = false; }
     }
-    logInput('external-stop', { hadTurn: turnActive, stopped, command: text, pending: pending.length });
+    logInput('external-stop', { hadTurn: turnActive, stopped, command: text, pending: pending.length, path });
     const result = stopped ? 'stopped' : turnActive ? 'failed' : 'no-turn';
     try { h.onExternalStop?.(result); } catch { /* fail-soft */ }
     if (result === 'no-turn') throw new Error('tui-stop-no-active-turn');
@@ -189,6 +196,7 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
       host = next;
       log('host-registered', { pending: pending.length });
       ensurePump();
+      if (pending.length > 0) notify();
       return () => {
         if (host !== next) return;
         host = null;
@@ -200,7 +208,7 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
       // `pty key`(input-key)는 «키»다 — 공백·`j` 처럼 출력 가능한 키도 종전대로 넣는다.
       if (keyCommandDepth > 0) return 'passthrough';
       const line = parseExternalTextLine(chars);
-      if (line && host && isExternalStopCommand(line.text)) return routeStop(host, line.text);
+      if (line && host && isExternalStopCommand(line.text)) return routeStop(host, line.text, 'control-ipc');
       let turnActive = false; let composer: string | undefined; let pendingKeys = false;
       if (host && line) {
         try { turnActive = host.isTurnActive(); composer = host.composerText(); pendingKeys = host.hasPendingKeys(); }
@@ -229,10 +237,26 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
       }
       pending = [...pending, { text: line!.text, at: now() }];
       log('route', { ...base, route: 'queued', pending: pending.length });
-      notify('queued');
+      notify();
       ensurePump();
       return 'queued';
     },
+    /**
+     * ⏹ 원시 pty 길 — 턴 중 stdin «한 청크»가 정확히 `/stop⏎`·`/esc⏎` 이면 `routeStop` 으로 보내고 true(키로 흘리지 않는다).
+     * 턴 밖·호스트 없음·Enter 없음·그 밖의 글은 false — 호출측이 종전대로 키를 넣는다.
+     */
+    routeRawStop(chunk: string): boolean {
+      const h = host;
+      if (!h) return false;
+      const line = parseExternalTextLine(chunk);
+      if (!line?.submit || !isExternalStopCommand(line.text)) return false;
+      let turnActive = false;
+      try { turnActive = h.isTurnActive(); } catch { turnActive = false; }
+      if (!turnActive) return false;
+      // 'failed'(중단 경로 없음)도 소비한다 — 표지(Esc 로 멈춰 주세요)는 routeStop 이 이미 남겼다.
+      try { routeStop(h, line.text, 'raw-pty'); } catch { /* 결과는 이벤트·표지로 남았다 */ }
+      return true;
+    },
     pump,
     pending: (): readonly ExternalInputItem[] => pending,
   };
@@ -249,3 +273,4 @@ const shared = createExternalInputQueue();
 
 export function registerExternalInputHost(host: ExternalInputHost): () => void { return shared.register(host); }
 export function routeExternalInput(chars: string): ExternalInputRoute { return shared.route(chars); }
+export function routeRawPtyStop(chunk: string): boolean { return shared.routeRawStop(chunk); }

package/src/intake-plane/already-built-hint.ts

@@ -0,0 +1,89 @@
+// ── ALREADY-BUILT-HINT — «이미 있는 기능» 알림 원시함수 (UX · 0.2.34 칸) ──────────
+//
+// RFC-harness-full-journey-as-graph §4f 판정 — 다른 폴더의 «이미 있는 기능»을 새 요구로
+// 넣으면 근거 링크(커밋·파일) 붙은 알림을 낸다 · 관련 없으면 0건 · 거절한 짝은 다시 묻지
+// 않는다. 순수 함수·부수효과 0. 관련도 점수는 세션 검색의 trigram FTS5 원시함수
+// (src/session/search-index.ts rankByTrigramFts — BM25, 낮을수록 관련도 높음)를 그대로
+// 재사용한다. DEV-FEATURE-MAP 행을 넘겨 부르는 인테이크·저작 경로 배선(intake.hint
+// 관측)은 다음 조각(남은 것)이다.
+
+import { rankByTrigramFts, type RankedDoc, type RankResult } from '../session/search-index.js';
+import { hashContent } from '../hasher.js';
+
+/** DEV-FEATURE-MAP 한 행 — «이미 있는 기능» 후보. evidence 가 비면 그 행은 버린다(근거 없으면 침묵). */
+export interface AlreadyBuiltFeature {
+  readonly devProject: string;
+  readonly feature: string;
+  readonly text: string;
+  readonly evidence: { readonly commit?: string; readonly file?: string };
+}
+
+/** 거절한 짝 — «요구 해시 ⊕ feature». 요구 해시는 hashContent(request)(sha256 hex). */
+export interface AlreadyBuiltRefusedPair {
+  readonly requestHash: string;
+  readonly feature: string;
+}
+
+export type AlreadyBuiltHintKind = 'already' | 'similar';
+
+/** A compact notification: one best match and at most two related matches. */
+const MAX_ALREADY_BUILT_HINTS = 3;
+
+/** 힌트 1건 — 근거 링크(커밋·파일) + BM25 점수(낮을수록 관련도 높음). */
+export interface AlreadyBuiltHint {
+  readonly kind: AlreadyBuiltHintKind;
+  readonly devProject: string;
+  readonly feature: string;
+  readonly evidence: { readonly commit?: string; readonly file?: string };
+  readonly score: number;
+}
+
+/** 근거 유무 — commit·file 중 하나라도 실값(빈 문자열 제외)이면 근거 있음. */
+function hasEvidence(evidence: AlreadyBuiltFeature['evidence']): boolean {
+  return (evidence.commit != null && evidence.commit !== '') || (evidence.file != null && evidence.file !== '');
+}
+
+/**
+ * 새 요구가 «이미 있는 기능»을 가리키는지 판정하는 순수 함수.
+ *
+ * - 후보의 배열 인덱스를 sessionId 로 사용해 rankByTrigramFts(request, docs) 로
+ *   BM25 관련도 점수를 매긴다(재사용 · 낮을수록 높음).
+ * - evidence 가 비면 그 행은 버리고(근거 없으면 침묵) refused 짝(요구 해시 ⊕ feature)에
+ *   있는 행은 뺀다.
+ * - 매칭 행 중 관련도순 상위 3건만 내고, 첫 행(최고 관련도)은 kind='already',
+ *   그 뒤는 kind='similar'.
+ * - 관련 없는 요구·3자 미만 요구·FTS 오류·남는 후보 없음 → [] (출력 없음 = 침묵).
+ */
+export function alreadyBuiltHints(
+  request: string,
+  features: readonly AlreadyBuiltFeature[],
+  refused: readonly AlreadyBuiltRefusedPair[],
+): AlreadyBuiltHint[] {
+  const requestHash = hashContent(request);
+  const candidates = features.filter((f) =>
+    hasEvidence(f.evidence)
+    && !refused.some((p) => p.requestHash === requestHash && p.feature === f.feature),
+  );
+  if (candidates.length === 0) return [];
+
+  const docs: RankedDoc[] = candidates.map((f, index) => ({
+    sessionId: String(index),
+    content: f.text,
+  }));
+  const ranked: RankResult[] | null = rankByTrigramFts(request, docs);
+  if (!ranked || ranked.length === 0) return []; // 관련 없는 요구 · <3자 · FTS 오류 → 침묵
+
+  const hints: AlreadyBuiltHint[] = [];
+  for (const r of ranked.slice(0, MAX_ALREADY_BUILT_HINTS)) {
+    const f = candidates[Number(r.sessionId)];
+    if (!f) continue;
+    hints.push({
+      kind: hints.length === 0 ? 'already' : 'similar',
+      devProject: f.devProject,
+      feature: f.feature,
+      evidence: { ...f.evidence },
+      score: r.score,
+    });
+  }
+  return hints;
+}