elanous 0.2.22 → 0.2.24

package/src/autopilot/build/llm-conflict-merge.ts

@@ -244,6 +244,7 @@ export async function mergeMainWithLlmResolve(
   });
   const unresolved = (outcome: LlmMergeOutcome & { status: 'conflict-unresolved'; failedFile: string }): LlmMergeOutcome => {
     debug.log('self-dev.merge', 'conflict-unresolved', { reason: outcome.reason, failedFile: outcome.failedFile, resolvedCount: resolvedFiles.length });
+    debug.log('self-dev.merge', 'merge-conflict-resolve', { attempt: 'merge', result: 'unresolved', files: [outcome.failedFile], ...(outcome.reason ? { reason: outcome.reason } : {}) });
     return measuredOutcome(outcome);
   };
   for (const f of files) {
@@ -315,7 +316,12 @@ export async function mergeMainWithLlmResolve(
     else llmResolved += 1;
   }
   const committed = seamOk(git.commit(worktreePath));
-  if (!committed.ok) { git.abort(worktreePath); return measuredOutcome(errorOutcome('commit', committed.errorDetail, resolvedFiles)); }
+  if (!committed.ok) {
+    git.abort(worktreePath);
+    debug.log('self-dev.merge', 'merge-conflict-resolve', { attempt: 'merge', result: 'unresolved', files: resolvedFiles, reason: 'commit-failed' });
+    return measuredOutcome(errorOutcome('commit', committed.errorDetail, resolvedFiles));
+  }
+  debug.log('self-dev.merge', 'merge-conflict-resolve', { attempt: 'merge', result: 'resolved', files: resolvedFiles });
   return measuredOutcome({
     status: llmResolved === 0 && deterministicResolved > 0 ? 'deterministic-resolved' : 'llm-resolved',
     resolvedFiles,
@@ -393,6 +399,157 @@ export function defaultGitMergeSeam(): MergeGitSeam {
   };
 }
 
+/**
+ * MERGE-CONFLICT-AUTO — 큰 파일의 충돌을 «hunk 단위»로 푼다.
+ * 🩸 10-10 run-448e450f: `src/llm.ts`(11k+ 줄) 충돌이 전체 파일 프롬프트 상한(`mergeConflictInputMaxChars`)을 넘어
+ *   `conflict-input-too-large` 로 시도조차 못 하고 사람 넘김(main-sync-blocked)이 됐다.
+ * ⇒ 파일 전체 대신 충돌 블록(`<<<<<<< `…`>>>>>>> `)과 앞뒤 문맥만 잘라 LLM 에 주고, 해결된 블록을 원 파일 자리에 다시 꿰맨다.
+ *   충돌 밖의 줄은 바이트 그대로다. 해결본은 호출부(`mergeMainWithLlmResolve`)의 마커·시험 선언·크기 붕괴 검사를 그대로 탄다.
+ */
+export interface ConflictHunk {
+  /** 블록 첫 줄(`<<<<<<< `)의 0-기준 줄 번호. */
+  start: number;
+  /** 블록 끝 줄(`>>>>>>> `)의 0-기준 줄 번호(포함). */
+  end: number;
+}
+
+/** 충돌 블록을 찾는다(순수). 짝이 안 맞으면 null — 꿰맬 수 없으니 hunk 경로를 쓰지 않는다. */
+export function findConflictHunks(content: string): ConflictHunk[] | null {
+  const lines = content.split('\n');
+  const hunks: ConflictHunk[] = [];
+  let open = -1;
+  let base = false;
+  let separator = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (/^<{7}(?: |\r?$)/.test(line)) {
+      if (open !== -1) return null;
+      open = i; base = false; separator = false;
+    } else if (/^>{7}(?: |\r?$)/.test(line)) {
+      // ⛔ 구분자(`=======`) 없는 블록은 꿰맬 수 없는 모양이다 — 종전 출구로.
+      if (open === -1 || !separator) return null;
+      hunks.push({ start: open, end: i });
+      open = -1;
+    } else if (open !== -1 && /^\|{7}(?: |\r?$)/.test(line)) {
+      // diff3 base 구간은 구분자 «앞»에 한 번만.
+      if (base || separator) return null;
+      base = true;
+    } else if (open !== -1 && /^={7}\r?$/.test(line)) {
+      if (separator) return null;
+      separator = true;
+    }
+  }
+  return open === -1 ? hunks : null;
+}
+
+/** hunk 해결 기본 문맥 줄 수(앞뒤 각각). */
+export const DEFAULT_CONFLICT_HUNK_CONTEXT_LINES = 40;
+
+export function conflictHunkResolvePrompt(
+  filePath: string, before: string, block: string, after: string, mergeTarget: string, index: number, total: number,
+  intent?: ResolverIntent,
+): string {
+  return [
+    '너는 git merge 충돌을 지능적으로 해결하는 엔지니어다. 파일이 커서 충돌 블록 «하나»와 그 앞뒤 문맥만 보여 준다.',
+    '  <<<<<<< ours   = 현재 브랜치(walker 가 이 미션에서 만든 산출물)',
+    '  ======= 사이   = 양쪽 버전',
+    `  >>>>>>> theirs = ${mergeTarget}(호출자가 해석해 전달한 정합 대상)`,
+    '',
+    ...resolverIntentLines(intent),
+    '해결 원칙:',
+    '- 양쪽의 의도를 **모두 보존**하며 종합한다(한쪽을 통째로 버리지 않는다).',
+    `- 같은 목적의 중복은 **theirs(${mergeTarget}) 버전을 채택**하고 ours 의 중복은 제거.`,
+    '- ours 에만 있는 고유 추가분은 **보존**해 theirs 와 합친다.',
+    '- 앞·뒤 문맥은 «참고용»이다 — 출력하지 않는다. 해결본이 그 문맥 사이에 들어가 문법적으로 이어져야 한다.',
+    '',
+    '⚠️ 충돌 블록(<<<<<<< 부터 >>>>>>> 까지)을 «대체할 줄들만» 출력하라. 충돌 마커 없이, 설명·코드펜스 없이.',
+    '',
+    `파일: ${filePath} · 충돌 블록 ${index + 1}/${total}`,
+    '앞 문맥(출력 금지):',
+    '```',
+    before,
+    '```',
+    '충돌 블록(이것을 대체):',
+    '```',
+    block,
+    '```',
+    '뒤 문맥(출력 금지):',
+    '```',
+    after,
+    '```',
+  ].join('\n');
+}
+
+/**
+ * 충돌 블록마다 `resolveHunk` 로 대체 줄을 받아 원 파일에 꿰맨다. 블록 하나라도 상한을 넘으면
+ * `MergeConflictInputTooLarge` 를 던진다(종전과 같은 사람 넘김). 짝이 안 맞는 마커면 null.
+ */
+export async function resolveConflictByHunks(
+  filePath: string, conflicted: string, mergeTarget: string, maxChars: number,
+  resolveHunk: (prompt: string) => Promise<string>,
+  contextLines = DEFAULT_CONFLICT_HUNK_CONTEXT_LINES,
+  intent?: ResolverIntent,
+): Promise<string | null> {
+  const hunks = findConflictHunks(conflicted);
+  if (hunks === null || hunks.length === 0) return null;
+  const lines = conflicted.split('\n');
+  // 1차: 블록마다 프롬프트를 «먼저» 다 만든다 — 하나라도 상한을 넘으면 LLM 을 한 번도 안 부르고 종전 출구.
+  const prompts: string[] = [];
+  for (let k = 0; k < hunks.length; k++) {
+    const { start, end } = hunks[k]!;
+    const prevEnd = k === 0 ? -1 : hunks[k - 1]!.end;
+    const nextStart = k === hunks.length - 1 ? lines.length : hunks[k + 1]!.start;
+    const block = lines.slice(start, end + 1).join('\n');
+    // 상한 안에 들 때까지 — 의도(ours·theirs·형제 PR)가 문맥보다 먼저다:
+    //   ① 의도 포함으로 문맥을 반씩 줄여(0 까지) 본다 → ② 그래도 안 들면 의도 없이 같은 순서로.
+    //   블록만으로도(문맥 0 · 의도 없음) 넘으면 그때만 종전 출구(too-large).
+    const hunkPrompt = (ctx: number, withIntent: ResolverIntent | undefined): string => {
+      const before = lines.slice(Math.max(prevEnd + 1, start - ctx), start).join('\n');
+      const after = lines.slice(end + 1, Math.min(nextStart, end + 1 + ctx)).join('\n');
+      return conflictHunkResolvePrompt(filePath, before, block, after, mergeTarget, k, hunks.length, withIntent);
+    };
+    let prompt = '';
+    for (const withIntent of intent ? [intent, undefined] : [undefined]) {
+      for (let ctx = contextLines; ; ctx = Math.floor(ctx / 2)) {
+        prompt = hunkPrompt(ctx, withIntent);
+        if (prompt.length <= maxChars || ctx === 0) break;
+      }
+      if (prompt.length <= maxChars) break;
+    }
+    if (prompt.length > maxChars) throw new MergeConflictInputTooLarge(prompt.length);
+    prompts.push(prompt);
+  }
+  // 2차: 해결하고 꿰맨다.
+  const out: string[] = [];
+  let cursor = 0;
+  for (let k = 0; k < hunks.length; k++) {
+    const { start, end } = hunks[k]!;
+    const raw = await resolveHunk(prompts[k]!);
+    const replacement = raw.replace(/^```[\w.-]*\r?\n?/, '').replace(/\r?\n?```\s*$/, '').replace(/(?:\r?\n)+$/, '');
+    // ⛔ 스프레드 대신 줄 단위 — 충돌 밖 구간이 아주 길어도 인자 수 한도에 안 걸린다.
+    for (let i = cursor; i < start; i++) out.push(lines[i]!);
+    // CRLF 파일이면 해결 줄도 CRLF 로 맞춘다(블록 끝 마커 줄의 줄 끝을 따른다).
+    const crlf = lines[end]!.endsWith('\r');
+    // ⛔ 해결 줄도 펼침(`push(...x)`) 없이 — 입력 상한은 LLM «출력» 줄 수를 막지 않는다(펼침은 인자 수 한도에서 RangeError).
+    if (replacement.length > 0) {
+      for (const line of replacement.split('\n')) out.push(crlf ? `${line.replace(/\r$/, '')}\r` : line.replace(/\r$/, ''));
+    }
+    // ⛔ 파일 끝 블록이 빈 해결본이면 앞 줄의 개행이 사라진다 — 빈 줄 하나로 그 개행을 남긴다(충돌 밖 바이트 불변).
+    else if (end === lines.length - 1 && start > 0) out.push('');
+    cursor = end + 1;
+  }
+  for (let i = cursor; i < lines.length; i++) out.push(lines[i]!);
+  return out.join('\n');
+}
+
+/** `tools.selfImplement.mergeConflictAuto` — 기본 on. `false` 면 큰 파일 hunk 해결을 끄고 종전(사람 넘김) 그대로. */
+export function mergeConflictAutoEnabled(raw: Record<string, unknown> | undefined): boolean {
+  const tools = raw?.tools;
+  const selfImplement = tools && typeof tools === 'object' ? (tools as Record<string, unknown>).selfImplement : undefined;
+  const value = selfImplement && typeof selfImplement === 'object' ? (selfImplement as Record<string, unknown>).mergeConflictAuto : undefined;
+  return value !== false;
+}
+
 /** 실 LLM 충돌 해결 어댑터(streamLLM·sol). 코드펜스/설명 제거해 완결 파일만. */
 export async function defaultLlmResolve(
   filePath: string, conflicted: string, mergeTarget: string,
@@ -404,10 +561,13 @@ export async function defaultLlmResolve(
     siblingIntent?: 'on' | 'off';
     /** Receives each resolver-phase `intent-resolve` decision (carried onto the merge outcome). */
     onIntentResolve?: (record: IntentResolveRecord) => void;
+    /** MERGE-CONFLICT-AUTO seam — overrides `tools.selfImplement.mergeConflictAuto` (default on). */
+    mergeConflictAuto?: boolean;
   } = {},
 ): Promise<string> {
   let rawConfig: { mergeConflictInputMaxChars?: unknown; mergeIntent?: unknown; siblingIntent?: unknown } | undefined;
-  try { rawConfig = getUserConfig().raw.selfImplement as typeof rawConfig; }
+  let rawRoot: Record<string, unknown> | undefined;
+  try { rawRoot = getUserConfig().raw; rawConfig = rawRoot.selfImplement as typeof rawConfig; }
   catch { /* unreadable config keeps the old resolver and default input limit */ }
   const configuredMax = rawConfig?.mergeConflictInputMaxChars;
   const maxChars = typeof configuredMax === 'number' && Number.isSafeInteger(configuredMax) && configuredMax > 0
@@ -417,13 +577,52 @@ export async function defaultLlmResolve(
     rawMode = rawConfig?.mergeIntent;
   }
   const mode = rawMode === 'shadow' || rawMode === 'on' ? rawMode : 'off';
-  const resolve = async (intent?: ResolverIntent): Promise<string> => {
-    const prompt = conflictResolvePrompt(filePath, conflicted, mergeTarget, intent);
-    if (prompt.length > maxChars) throw new MergeConflictInputTooLarge(prompt.length);
+  const conflictModel = process.env.ELANOUS_CONFLICT_MODEL || tierModel('better');
+  const ask = async (prompt: string): Promise<string> => {
     const streamLLM = options.stream ?? (await import('../../llm.js')).streamLLM;
-    const out = await streamLLM([{ role: 'user', content: prompt }], () => {}, { model: process.env.ELANOUS_CONFLICT_MODEL || tierModel('better'), reasoningEffort: 'medium' });
+    const out = await streamLLM([{ role: 'user', content: prompt }], () => {}, { model: conflictModel, reasoningEffort: 'medium' });
     // ⛔ 라우터는 공급자가 전부 막히면 던지지 않고 오류 문구를 돌려준다 — 그것은 파일 내용이 아니다.
     if (PROVIDER_FAILURE_TEXT.test(out)) throw new Error(`conflict resolve: LLM provider failure for ${filePath}`);
+    return out;
+  };
+  const resolve = async (intent?: ResolverIntent): Promise<string> => {
+    const prompt = conflictResolvePrompt(filePath, conflicted, mergeTarget, intent);
+    const autoOn = prompt.length > maxChars && (options.mergeConflictAuto ?? mergeConflictAutoEnabled(rawRoot));
+    if (autoOn && intent !== undefined) {
+      // 의도 때문에만 상한을 넘으면 의도 없는 전체 파일 프롬프트가 먼저다(hunk 로 가지 않는다).
+      const plain = conflictResolvePrompt(filePath, conflicted, mergeTarget);
+      if (plain.length <= maxChars) {
+        const out = await ask(plain);
+        return `${out.replace(/^```[\w.-]*\n?/, '').replace(/\n?```\s*$/, '').trimEnd()}\n`;
+      }
+    }
+    if (prompt.length > maxChars) {
+      // MERGE-CONFLICT-AUTO — 전체 파일이 상한을 넘으면 충돌 hunk 와 앞뒤 문맥만 잘라 푼다(노브 off 면 종전 그대로).
+      // 노브 off 면 종전 그대로(LLM 호출 0) — 위 의도 없는 전체 파일 재시도도 노브 on 에서만.
+      if (!autoOn) throw new MergeConflictInputTooLarge(prompt.length);
+      let stitched: string | null;
+      try {
+        stitched = await resolveConflictByHunks(filePath, conflicted, mergeTarget, maxChars, ask, DEFAULT_CONFLICT_HUNK_CONTEXT_LINES, intent);
+      } catch (error) {
+        debug.log('self-dev.merge', 'merge-conflict-resolve', {
+          attempt: 'hunk', result: 'unresolved', files: [filePath], model: conflictModel, inputChars: prompt.length,
+          error: error instanceof MergeConflictInputTooLarge ? 'hunk-input-too-large' : String((error as Error)?.message ?? error).slice(0, 200),
+        }, { level: 'warn' });
+        throw error instanceof MergeConflictInputTooLarge ? new MergeConflictInputTooLarge(prompt.length) : error;
+      }
+      if (stitched === null) {
+        debug.log('self-dev.merge', 'merge-conflict-resolve', { attempt: 'hunk', result: 'unresolved', files: [filePath], model: conflictModel, inputChars: prompt.length, error: 'hunk-markers-unbalanced' }, { level: 'warn' });
+        throw new MergeConflictInputTooLarge(prompt.length);
+      }
+      const hunks = findConflictHunks(conflicted)?.length ?? 0;
+      // ⚠️ `stitched` 는 «꿰맴»까지다 — 최종 판정(마커·시험 선언·크기 붕괴)은 mergeMainWithLlmResolve 의 merge-conflict-resolve(attempt: 'merge').
+      debug.log('self-dev.merge', 'merge-conflict-resolve', {
+        attempt: 'hunk', result: hasConflictMarkers(stitched) ? 'unresolved' : 'stitched', files: [filePath], model: conflictModel, inputChars: prompt.length, hunks,
+      });
+      // 끝 개행 상태도 원본 그대로(충돌 밖 줄 바이트 불변).
+      return stitched;
+    }
+    const out = await ask(prompt);
     return `${out.replace(/^```[\w.-]*\n?/, '').replace(/\n?```\s*$/, '').trimEnd()}\n`;
   };
   const collect = () => collectMergeIntent({ worktreePath: options.worktreePath ?? process.cwd(), filePath, mergeTarget, git: options.git ?? defaultIntentGit });
@@ -558,6 +757,16 @@ function siblingIntentLines(siblings: SiblingPrIntent[] | undefined): string[] {
   ];
 }
 
+/** 전체 파일·hunk 프롬프트가 공유하는 의도 줄(ours·theirs·형제 PR). */
+function resolverIntentLines(intent: ResolverIntent | undefined): string[] {
+  return intent ? [
+    `ours 의 의도: ${intent.ours ?? '(확인 불가)'}`,
+    `theirs 에 먼저 착지한 변경: ${intent.theirs.length ? intent.theirs.join(' · ') : '(확인 불가)'}`,
+    '',
+    ...siblingIntentLines(intent.siblings),
+  ] : [];
+}
+
 export function conflictResolvePrompt(filePath: string, conflictedContent: string, mergeTarget: string, intent?: ResolverIntent): string {
   return [
     '너는 git merge 충돌을 지능적으로 해결하는 엔지니어다. 아래 파일은 3-way merge 충돌 마커를 포함한다:',
@@ -565,12 +774,7 @@ export function conflictResolvePrompt(filePath: string, conflictedContent: strin
     '  ======= 사이   = 양쪽 버전',
     `  >>>>>>> theirs = ${mergeTarget}(호출자가 해석해 전달한 정합 대상)`,
     '',
-    ...(intent ? [
-      `ours 의 의도: ${intent.ours ?? '(확인 불가)'}`,
-      `theirs 에 먼저 착지한 변경: ${intent.theirs.length ? intent.theirs.join(' · ') : '(확인 불가)'}`,
-      '',
-      ...siblingIntentLines(intent.siblings),
-    ] : []),
+    ...resolverIntentLines(intent),
     '해결 원칙:',
     '- 양쪽의 의도를 **모두 보존**하며 종합한다(한쪽을 통째로 버리지 않는다).',
     `- 같은 목적의 중복(예: 같은 테스트·같은 함수)은 **theirs(${mergeTarget}) 버전을 채택**하고 ours 의 중복은 제거.`,

package/src/autopilot/codebase-grounding.ts

@@ -0,0 +1,44 @@
+import type { HarnessGroundingProvenance } from '../self-implement/context-capsule.js';
+
+// ⚠️ `<name>` 은 한 구간이며 디렉터리는 정확히, SKILL.md 파일명만 대소문자를 무시한다.
+const CLAUDE_SKILL_DOCUMENT = /(?:^|\/)\.claude\/skills\/[^/]+\/[Ss][Kk][Ii][Ll][Ll]\.[Mm][Dd]$/;
+
+/** The sole path policy for repository implementation candidates. */
+export function isRepositoryImplementationCandidate(path: string): boolean {
+  return !CLAUDE_SKILL_DOCUMENT.test(path.replace(/\\/g, '/'));
+}
+
+export interface PersistentGroundingEvidenceItem {
+  text: string;
+  sourceKind?: HarnessGroundingProvenance;
+}
+
+export interface DocumentGroundingMatch {
+  path: string;
+  score: number;
+  matchedTerms: string[];
+  excerpt: string;
+}
+
+export interface CodebaseGrounding {
+  grounded: boolean;
+  context: string;   // 분해 objective 에 fold 할 "기존 관련 코드/문서" 맵
+  /** `.claude/skills/<name>/SKILL.md` 만 제외한다. 일반적인 저장소 소스 판별은 아니다. */
+  files: string[];
+  /** Persistent loop completion-evidence lines, preserved verbatim after Read-path verification. */
+  persistentEvidence?: string[];
+  /** Positional source associations preserve distinct provenance for duplicate evidence text. */
+  persistentEvidenceItems?: readonly PersistentGroundingEvidenceItem[];
+  persistentStopReason?: string;
+  /** 코드 접지 채널의 상태. 빈 파일 결과의 서로 다른 원인을 구분한다. */
+  codeChannel?: 'ok' | 'disabled' | 'failed' | 'incomplete';
+  skillFacts: string[];
+  codeFacts: string[];
+  memoryFacts: string[];
+  documentFacts: string[];
+  documentMatches?: DocumentGroundingMatch[];
+  searchTerms?: string[];
+  genericSearchScope?: boolean;
+  refFacts: string[];
+  ptyFacts: string[];
+}

package/src/autopilot/llm-control-brain.ts

@@ -13,6 +13,7 @@
 import type { RunSupervisor, ControlDecision, ControlObservation } from './pty-control-loop.js';
 import { formatStallContext } from './stall-context.js';
 import type { LLMMessage } from '../llm.js';
+import type { LLMProviderName, ReasoningLevel } from '../user-config.js';
 import { debug } from '../debug/log.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { MAX_PTY_KEY_REPEAT } from '../pty-shell/pty-mouse.js';
@@ -30,6 +31,9 @@ export interface LlmControlBrainOpts {
   /** LLM 스트림(미주입 시 실제 streamLLM lazy-import). */
   readonly stream?: StreamLLMFn;
   readonly model?: string;
+  readonly provider?: LLMProviderName;
+  /** Per-brain tier reasoning; applied to provider construction without changing global config. */
+  readonly reasoningLevel?: ReasoningLevel;
   readonly maxTokens?: number;
   readonly temperature?: number;
   /** 스텝당 LLM 호출 상한(ms). 초과 시 wait(fail-soft) — provider 멈춰도 루프의 stuck/budget/
@@ -134,7 +138,15 @@ export function createLlmControlBrain(opts: LlmControlBrainOpts): RunSupervisor
   };
   // lazy — 테스트가 stream 주입 시 llm.js 로드 안 함.
   const stream: StreamLLMFn = opts.stream
-    ?? (async (m, cb, o) => (await import('../llm.js')).streamLLM(m, cb, o ?? {}));
+    ?? (async (m, cb, o) => {
+      const llm = await import('../llm.js');
+      const config = opts.provider ? (await import('../user-config.js')).getUserConfig() : undefined;
+      const provider = config && opts.provider
+        ? llm.getProviderForConfig({ ...config, llm: { ...config.llm, provider: opts.provider, model: opts.model ?? config.llm.model,
+            ...(opts.reasoningLevel ? { reasoningLevel: opts.reasoningLevel, codexReasoning: undefined } : {}) } }, opts.model)
+        : undefined;
+      return llm.streamLLM(m, cb, { ...o, ...(provider ? { initialProvider: provider } : {}) });
+    });
 
   return {
     async decide(obs: ControlObservation, externalSignal?: AbortSignal): Promise<ControlDecision> {

package/src/autopilot/mission-codebase-gate.ts

@@ -16,7 +16,12 @@ import { searchMemories } from '../memory.js';
 import { debug } from '../debug/log.js';
 import { localRefGroundingDigest } from '../agent/ref-grounding.js';
 import { listContextCapsules } from '../self-implement/context-capsule-store.js';
-import type { HarnessContextCapsule, HarnessGroundingProvenance } from '../self-implement/context-capsule.js';
+import type { HarnessContextCapsule } from '../self-implement/context-capsule.js';
+import { isRepositoryImplementationCandidate, type DocumentGroundingMatch } from './codebase-grounding.js';
+import { registerGoalAuthorGroundMission } from '../self-implement/goal-author.js';
+export { isRepositoryImplementationCandidate } from './codebase-grounding.js';
+export type CodebaseGrounding = import('./codebase-grounding.js').CodebaseGrounding;
+export type { DocumentGroundingMatch, PersistentGroundingEvidenceItem } from './codebase-grounding.js';
 import { groundPersistently, type PersistentGroundingDeps } from '../skills/tools/persistent-grounding.js';
 import type { LLMUsage } from '../prompt-cache/types.js';
 import { llmUsageCostFields } from '../budget/llm-cost.js';
@@ -38,75 +43,6 @@ function logLlmUsage(site: 'codebase-gate-injected' | 'codebase-gate-dynamic', m
   } catch { /* usage observation must not change grounding */ }
 }
 
-// ⚠️ `<name>` 은 **한 구간**이다(리뷰 should-fix) — `.+` 는 중첩 경로까지 삼켜 정책 설명과 어긋난다.
-// ⛔ **대소문자를 가리지 않는다**(2026-07-30 실측) — 실물로 `~/.claude/skills/project-onboarding/skill.md`
-//    (전부 소문자)가 존재하고, 종전 정규식은 그것을 **구현 후보로 실었다**. macOS 기본 FS 는
-//    case-insensitive 라 같은 스킬이 어느 표기로도 존재할 수 있다.
-//    ⊕ 같은 형태의 우회로를 `[S·round6]` 가 자기 가드(`.MD`)에서 먼저 찾았다 — 같은 관례가 둘을 속였다.
-// ⛔ `/i` 를 **전체에 걸지 않는다**(리뷰 must-fix) — 그러면 `.CLAUDE/SKILLS/...` 까지 제외해
-//    "정책 범위는 `.claude/skills/<name>/SKILL.md` 한 구간" 이라는 내 경계를 내가 넓힌다.
-//    **디렉터리는 정확히**, **파일명만** 대소문자를 무시한다.
-const CLAUDE_SKILL_DOCUMENT = /(?:^|\/)\.claude\/skills\/[^/]+\/[Ss][Kk][Ii][Ll][Ll]\.[Mm][Dd]$/;
-
-/** The sole path policy for repository implementation candidates. */
-export function isRepositoryImplementationCandidate(path: string): boolean {
-  return !CLAUDE_SKILL_DOCUMENT.test(path.replace(/\\/g, '/'));
-}
-
-export interface PersistentGroundingEvidenceItem {
-  text: string;
-  sourceKind?: HarnessGroundingProvenance;
-}
-
-export interface CodebaseGrounding {
-  grounded: boolean;
-  context: string;   // 분해 objective 에 fold 할 "기존 관련 코드/문서" 맵
-  /** ⚠️ 이 판별은 **`.claude/skills/<name>/SKILL.md` 만** 제외한다 — "저장소 소스만" 을
-   *  일반적으로 가려내지 않는다(리뷰 should-fix: 과장 금지). 실측으로 확인된 오분류가 그것뿐이라
-   *  안 잰 것을 규칙으로 만들지 않았다. */
-  files: string[];
-  /** Persistent loop completion-evidence lines, preserved verbatim after Read-path verification. */
-  persistentEvidence?: string[];
-  /**
-   * Per-item source associations for persistent evidence. Association is positional rather
-   * than text-keyed so duplicate evidence text can retain distinct provenance.
-   */
-  persistentEvidenceItems?: readonly PersistentGroundingEvidenceItem[];
-  /** Persistent grounding loop's observed stop reason, including no-candidate outcomes. */
-  persistentStopReason?: string;
-  /** 코드 접지 «채널»의 상태 — ⛔ `files: []` 의 세 뜻을 가른다(2026-08-11 72차 실측).
-   *  `ok` 채널이 돌았다(결과가 0이어도 «찾아본» 것이다) · `disabled` 호출자가 껐다 ·
-   *  `failed` 채널이 «실패»했다(제공자 오류 등 — 그 0 은 「없다」가 «아니다») ·
- *  `incomplete` 채널이 «돌긴 했는데 목표를 못 끝냈다»(`stopReason !== goal_complete`) —
- *    그때 후보는 «일부러» 비운다(검증 안 된 것을 파일로 주장하지 않는다). 📏 72차 전수 400건에서
- *    후보 0인 finished 5건이 «전부» `end_turn` 이었다 ⇒ 「성공인데 0」은 «없는 수수께끼»였다.
-   *  ⛔ 이 값이 없던 동안, 제공자 과부하로 난 `files: []` 가 「ask 에 앵커가 없다」로 사람에게 보고됐고
-   *  두 트랙이 그 문면을 믿고 ask 를 여러 번 다시 썼다(상관 17/17). */
-  codeChannel?: 'ok' | 'disabled' | 'failed' | 'incomplete';
-  /** ★ L3 — 탐색이 찾은 skill 계약 팩트(`[skill:name] <계약>`). 경로가 아니라 내용이라 build seed→PLAN.md
-   *  로 실려 구현 에이전트가 Read 없이도 계약 보유. 없으면 []. */
-  skillFacts: string[];
-  /** ★ L4 — grounded 코드 파일의 export 심볼 팩트(`[code:file] sym1, sym2`). decompose 가 코드 재사용을
-   *  추측/환각(예: 없는 "URL helper")하지 않게 **실제 export 심볼**을 실어 나른다. 없으면 []. */
-  codeFacts: string[];
-  /** ★ P2 — 검색공간 3박자 확장(기억·자기이력·문서벡터) 팩트(`[memory:type]`/`[self:kind]`/`[doc]`). ⚠️ 참조
-   *  컨텍스트(사실 배경)로만 쓰고 files/reusables(파일 실존 주장)에 넣지 않는다(mirage 가드). 없으면 []. */
-  memoryFacts: string[];
-  /** 저장소 `docs/` 검색 후보. 문서 근거를 보존하되 고칠 구현 파일 `files`에는 승격하지 않는다. */
-  documentFacts: string[];
-  /** 문서 검색의 실제 랭킹 근거. 저작기는 이 메타데이터로만 scope boundary를 선별한다. */
-  documentMatches?: DocumentGroundingMatch[];
-  /** 문서·코드 검색에 실제 사용한 확장 term. 저작기가 문서 후보의 관련도와 근거를 설명할 때만 쓴다. */
-  searchTerms?: string[];
-  /** ask에 저장소 고유명사/식별자가 없어 일반 검색어만 사용했음을 나타낸다. 빈 결과는 부재가 아니라 검색 범위의 미지다. */
-  genericSearchScope?: boolean;
-  /** 로컬 reference repository 팩트(`[ref:name] /absolute/path`). 참조 컨텍스트로만 쓰며 repo files 로 주장하지 않는다. */
-  refFacts: string[];
-  /** ★ F2(2026-07-25) — 상류 PTY 잡 capsule 팩트(`[pty:<id>] <objective> — 완료기준…`). 검색-코퍼스로 관련
-   *  상류 산출을 grounding 에 편입(dependsOn 없이·§11 컨텍스트 교환). 참조 컨텍스트로만(files 승격 아님). 없으면 []. */
-  ptyFacts: string[];
-}
-
 /** 구현·변경·분석형 골 판정 — 기존 자산을 다루는 미션(순수 단발 조회 제외). 순수함수(테스트). */
 export function isImplementationGoal(goal: string): boolean {
   const g = goal.toLowerCase();
@@ -229,13 +165,6 @@ export function hasRepositorySpecificIdentifier(goal: string, identifiers: reado
   });
 }
 
-export interface DocumentGroundingMatch {
-  path: string;
-  score: number;
-  matchedTerms: string[];
-  excerpt: string;
-}
-
 /** git grep 으로 키워드 매칭 구현 파일(src·scripts) 상위 N. 랭킹은 **distinct term coverage**
  *  (서로 다른 키워드가 겹치는 파일 = 진짜 관련)가 핵심 — 흔한 단어(session 등) 하나만 걸린
  *  무관 파일을 밀어낸다. + 파일명 히트 + 내용 히트 + src(구현코드) 우선. 저장소 문서는
@@ -769,3 +698,5 @@ export async function groundMissionInCodebase(
     observeTiming();
   }
 }
+
+registerGoalAuthorGroundMission(groundMissionInCodebase);

package/src/autopilot/mission-critique.ts

@@ -106,12 +106,25 @@ export function buildCritiquePrompt(input: { planBody: string; changedFiles: str
   ].join('\n');
 }
 
-/** LLM 응답 파싱 → verdict + findings. 순수함수(LLM node 규칙). */
+/** 판정 줄 — «줄 머리» VERDICT 만 판정으로 읽는다(본문 중간 인용·설명 속 «VERDICT:» 오인 방지).
+ *  들여쓰기는 허용(mission-engine 의 미션 판정 파서와 같은 앵커). */
+const CRITIQUE_VERDICT_LINE = /^[ \t]*VERDICT:\s*(PASS|WARN|FAIL)/im;
+/** 판정 줄이 없을 때 findings 에 남기는 fail-closed 사유(REVIEW-NO-VERDICT-FAILCLOSED #25937). */
+const NO_VERDICT_FINDING = '비평 판정 줄(VERDICT) 없음 — 판정 없음은 통과가 아니다(fail-closed · REVIEW-NO-VERDICT-FAILCLOSED #25937)';
+const MAX_CRITIQUE_FINDINGS = 4;
+
+/** LLM 응답 파싱 → verdict + findings. 순수함수(LLM node 규칙).
+ *  ⛔ 판정 줄이 «없으면» pass 로 기본하지 않는다(칸 MISSION-CRITIQUE-FAILCLOSED · #25937):
+ *  «판정 없음 = 통과 아님» ⇒ verdict 'warn' + 사유 finding.
+ *  'fail' 이 아니라 'warn' 인 이유 — 소비측(nocturnal-runner)은 critique verdict==='fail' 에
+ *  gate-failed(재구현 요구)를 건다. «비평가 응답의 형식 결함»을 «구현 훼손」으로
+ *  오귀속시키는 것이다. 'warn' 은 PR 본문(renderCritique)·자율 원장에 그대로 표시되어 사람(HITL)이 판단한다.
+ *  (post-PR 리뷰 축 parseReviewResult 는 substrate 가 `reviewed:false` 로 같은 fail-closed 를 이미 한다.) */
 export function parseLLMCritique(text: string): { verdict: CritiqueResult['verdict']; findings: string[] } {
-  const vm = /VERDICT:\s*(PASS|WARN|FAIL)/i.exec(text);
-  const verdict = (vm ? vm[1]!.toLowerCase() : 'pass') as CritiqueResult['verdict'];
-  const findings = text.split('\n').map((l) => l.trim()).filter((l) => l.startsWith('- ')).map((l) => l.slice(2).trim()).slice(0, 4);
-  return { verdict, findings };
+  const bullets = text.split('\n').map((l) => l.trim()).filter((l) => l.startsWith('- ')).map((l) => l.slice(2).trim());
+  const vm = CRITIQUE_VERDICT_LINE.exec(text);
+  if (!vm) return { verdict: 'warn', findings: [NO_VERDICT_FINDING, ...bullets].slice(0, MAX_CRITIQUE_FINDINGS) };
+  return { verdict: vm[1]!.toLowerCase() as CritiqueResult['verdict'], findings: bullets.slice(0, MAX_CRITIQUE_FINDINGS) };
 }
 
 /** ★ R1 결정론 + LLM 비평(대표 2026-07-12) — 결정론(R0) 먼저, llmReview 주입 시 LLM 심층 비평

package/src/autopilot/mission-feasibility-negotiate.ts

@@ -11,7 +11,7 @@
 // 2 예산(§8-5·config-first): maxStalls(언제 협상) · maxReplans(언제 partial 포기). a6230f 실측 튜닝.
 // 제1원칙: 협상 제안을 debug.log('mission.negotiate')로 관측.
 
-import { getUserConfig } from '../user-config.js';
+import { getUserConfig, resolveRoleLlm } from '../user-config.js';
 import { debug } from '../debug/log.js';
 
 export interface FeasibilityBudget {
@@ -104,16 +104,17 @@ function buildNegotiatePrompt(input: NegotiateInput, overBudget: boolean): strin
   ].filter(Boolean).join('\n');
 }
 
-async function defaultJudge(prompt: string): Promise<string> {
-  // ★ 모델 기반 provider 라우팅(2026-07-14) — 협상은 강한 추론이 핵심이라 기본 opus 4.8(대표 셋업).
-  //   getProvider(model)로 모델 계열 라우팅(claude-* → anthropic·env/config 키)해 활성 provider(codex 등)
-  //   무관하게 지목 모델이 닿는다. resolveDefaultProvider(활성 반환)면 opus 를 codex 로 보내 400→fail-soft.
-  //   env(ELANOUS_NEGOTIATE_MODEL·ELANOUS_DECOMPOSE_MODEL)로 override 가능.
-  const { streamLLM, getProvider } = await import('../llm.js');
-  const model = process.env.ELANOUS_NEGOTIATE_MODEL || process.env.ELANOUS_DECOMPOSE_MODEL || 'claude-opus-4-8';
-  const provider = getProvider(model);
+export async function defaultJudge(prompt: string): Promise<string> {
+  const { streamLLM, getProvider, PROVIDERS } = await import('../llm.js');
+  const override = process.env.ELANOUS_NEGOTIATE_MODEL || process.env.ELANOUS_DECOMPOSE_MODEL;
+  const resolved = override ? undefined : resolveRoleLlm('planning');
+  const model = override || resolved!.model;
+  const provider = override ? getProvider(model) : PROVIDERS[resolved!.provider];
+  const providerName = override ? provider.name : resolved!.provider;
+  if (!provider) throw new Error(`Unknown planning provider: ${providerName}`);
+  debug.log('llm.role-pin', 'resolved', { site: 'feasibility-negotiate', role: 'planning', model, provider: providerName, source: override ? 'env' : resolved!.source });
   return streamLLM([{ role: 'user', content: prompt }], () => {}, {
-    model, reasoningEffort: 'medium', ...(provider ? { provider } : {}),
+    model, provider, usageRole: 'planning', reasoningEffort: 'medium',
   });
 }
 

package/src/autopilot/mission-trace.ts

@@ -91,6 +91,17 @@ export function rollupDerived(derived: DerivedJob[]): MissionRollup {
 
 export interface TracePaths { schedulesDb?: string; tasksDb?: string; surfaceEventsDb?: string }
 
+/** 크론 행 목록 → 파생물(순수 · 행→DerivedJob 매핑의 «단일 소유»).
+ *  ⛔ 목록 화면(`/v1/missions` 카드)도 이 함수를 쓴다 — 크론 매핑을 두 번
+ *  쓰면 「트레이스는 stale 인데 카드는 ok」 갈림이 생긴다.
+ *  `staleIds` 는 `scheduleHealth(rows).stale` 로 «한 번» 구해 넣는다. */
+export function cronRowsToDerived(
+  rows: readonly ScheduleRow[],
+  staleIds: ReadonlySet<string>,
+): DerivedJob[] {
+  return rows.map(r => cronToDerived(r, staleIds.has(r.id)));
+}
+
 /** 크론 파생물 — schedule_registry.autopilot_id = apmId + scheduleHealth 상태. */
 function fetchCronDerived(apmId: string, schedulesDb?: string): DerivedJob[] {
   try {
@@ -98,7 +109,7 @@ function fetchCronDerived(apmId: string, schedulesDb?: string): DerivedJob[] {
     try {
       const rows = listSchedules(db);
       const staleIds = new Set(scheduleHealth(rows).stale.map(s => s.id));
-      return rows.filter(r => r.autopilot_id === apmId).map(r => cronToDerived(r, staleIds.has(r.id)));
+      return cronRowsToDerived(rows.filter(r => r.autopilot_id === apmId), staleIds);
     } finally { db.close(); }
   } catch { return []; }
 }

package/src/autopilot/pr-manager.ts

@@ -209,8 +209,16 @@ export function resolveDeliverableBase(
   explicit?: string,
 ): string | undefined {
   const e = explicit?.trim();
-  if (e) return e;
   const opts = { cwd };
+  if (e) {
+    if (e.startsWith('origin/') || run('git', ['-C', cwd, 'rev-parse', '--verify', '--quiet', e], opts).ok) return e;
+    const resolved = `origin/${e}`;
+    if (run('git', ['-C', cwd, 'rev-parse', '--verify', '--quiet', resolved], opts).ok) {
+      debug.log('autopilot.pr-manager', 'base-resolved-remote', { explicit: e, resolved });
+      return resolved;
+    }
+    return e;
+  }
   const head = run('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'origin/HEAD'], opts);
   const headRef = head.ok ? head.out.trim() : '';
   // `origin/HEAD` 미설정 리포는 "origin/HEAD" 를 그대로 되돌려주기도 한다 → 해소 실패로 취급.
@@ -359,8 +367,9 @@ export function makePrManager(runner: CmdRunner = defaultCmdRunner): PrManager {
       //   (node_modules·apps/pwa/out 심링크)를 이미 자동 skip 하는데, `:(exclude)<ignored>` 로 명시 지목하면
       //   git 이 "paths ignored by .gitignore … use -f" 로 exit 1 을 뱉는다(staging 은 성공하지만 exit≠0).
       //   그간 이게 add 실패로 오판돼 makePr null→pr-failed→budget 오힐 교착. gitignore 안 된 것만 exclude.
-      // ★ 최초 base 해석을 일반 경로의 판정과 PR 생성에 그대로 공유한다. self-base 인수 발사만
-      //   `branch..HEAD`의 구조적 0을 피하려 upstream 비교 ref와 기본 PR base를 추가 해석한다.
+      // ★ 최초 base 해석을 일반 경로의 판정과 PR 생성에 그대로 공유한다. 명시 base가 원격 추적으로만
+      //   존재하면 여기서 해석한 ref로 rev-list·diff를 비교하고 PR 생성에는 브랜치명만 전달한다.
+      //   self-base 인수 발사만 `branch..HEAD`의 구조적 0을 피하려 upstream 비교 ref와 기본 PR base를 추가 해석한다.
       const resolvedBase = resolveDeliverableBase(run, cwd, input.base);
       const selfBase = Boolean(resolvedBase && isBranchSelfRef(resolvedBase, input.branch));
       let comparisonBase = resolvedBase;