elanous 0.2.10 → 0.2.12

package/src/intake-plane/front-route-classifier.ts

@@ -1,7 +1,6 @@
 import { debug } from '../debug/log.js';
-import type { ModelRole } from '../user-config.js';
-import type { ResolveRoleProviderFn, StreamLlmFn, ProviderRegistry } from './runtime-callables.js';
-import { extractJsonBlock } from './decompose.js';
+import type { ResolveRoleProviderFn, StreamLlmFn } from './runtime-callables.js';
+import { judge } from '../llm/judge-layer.js';
 import {
   INTAKE_FRONT_ROUTE_TRACKS,
   type IntakeFrontRouteDecision,
@@ -14,17 +13,6 @@ interface ClassifierDeps {
   minConfidence?: number;
 }
 
-function loadRoleProvider(): ResolveRoleProviderFn {
-  const { resolveRoleLlm } = require('../user-config.js') as {
-    resolveRoleLlm: (role: ModelRole) => { provider: string; model: string };
-  };
-  const { PROVIDERS } = require('../llm.js') as { PROVIDERS: ProviderRegistry };
-  return (role) => {
-    const resolved = resolveRoleLlm(role);
-    return { provider: PROVIDERS[resolved.provider] ?? { name: resolved.provider }, model: resolved.model };
-  };
-}
-
 /** Classify only after the deterministic front-route rules return rule-unknown. */
 export async function classifyIntakeFrontRoute(
   text: string,
@@ -43,32 +31,38 @@ export async function classifyIntakeFrontRoute(
   const failed = (cause: string) => finish('ask-human', 0, `classifier-failed:${cause}`, 'failed');
 
   try {
-    const rolePick = (deps.resolveRoleProvider ?? loadRoleProvider())('classify');
-    provider = rolePick.provider.name;
-    const streamLLM = deps.streamLLM ?? (require('../llm.js') as { streamLLM: StreamLlmFn }).streamLLM;
-    const response = await streamLLM([
-      { role: 'system', content: [
-        'Classify the intake text into exactly one track:',
-        'absorb: read, save, or summarize external material.',
-        'tasks: a list of independent to-dos.',
-        'graph: an implementation or multi-step workflow request.',
-        'ask-human: ambiguous intent requiring human choice.',
-        'Return only one JSON object: {"track":"...","confidence":0.0,"reason":"..."}. Confidence must be between 0 and 1.',
-      ].join('\n') },
-      { role: 'user', content: text },
-    ], () => {}, { provider: rolePick.provider, ...(rolePick.model ? { model: rolePick.model } : {}), usageRole: 'classify' });
-
-    // 실제 모델은 JSON 을 ```json 펜스로 감싸거나 앞뒤에 말을 붙이곤 한다 — 같은 디렉토리의 다른 호출자와 같은 관대한 추출을 쓴다.
-    const parsed: unknown = extractJsonBlock(response);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return failed('invalid-json');
-    const candidate = parsed as Record<string, unknown>;
-    if (typeof candidate.track !== 'string' ||
-      !(INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(candidate.track)) return failed('invalid-track');
-    if (typeof candidate.confidence !== 'number' || !Number.isFinite(candidate.confidence) ||
-      candidate.confidence < 0 || candidate.confidence > 1) return failed('invalid-confidence');
-    if (typeof candidate.reason !== 'string') return failed('invalid-reason');
+    const decision = await judge({
+      site: 'intake.front-route',
+      prompt: text,
+      messages: [
+        { role: 'system', content: [
+          'Classify the intake text into exactly one track:',
+          'absorb: read, save, or summarize external material.',
+          'tasks: a list of independent to-dos.',
+          'graph: an implementation or multi-step workflow request.',
+          'ask-human: ambiguous intent requiring human choice.',
+          'Return only one JSON object: {"track":"...","confidence":0.0,"reason":"..."}. Confidence must be between 0 and 1.',
+        ].join('\n') },
+        { role: 'user', content: text },
+      ],
+      streamLLM: deps.streamLLM,
+      resolveRoleProvider: deps.resolveRoleProvider,
+      schema: (parsed) => {
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+        const candidate = parsed as Record<string, unknown>;
+        if (typeof candidate.track !== 'string' ||
+          !(INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(candidate.track)) return null;
+        if (typeof candidate.confidence !== 'number' || !Number.isFinite(candidate.confidence) ||
+          candidate.confidence < 0 || candidate.confidence > 1) return null;
+        if (typeof candidate.reason !== 'string') return null;
+        return { track: candidate.track as IntakeFrontRouteTrack, confidence: candidate.confidence, reason: candidate.reason };
+      },
+    });
+    provider = decision.ok ? decision.provider : provider;
+    if (!decision.ok) return failed(decision.reason === 'schema' ? 'invalid-json' : 'llm-error');
+    const candidate = decision.value;
 
-    const track = candidate.track as IntakeFrontRouteTrack;
+    const track = candidate.track;
     const confidence = candidate.confidence;
     if (confidence < (deps.minConfidence ?? 0.6)) {
       return finish('ask-human', confidence, `classifier-low-confidence:${track}`, 'low-confidence');

package/src/intake-plane/persona-answer.ts

@@ -0,0 +1,30 @@
+import { debug } from '../debug/log.js';
+import { resolveMention, type PersonaSource } from '../persona/mention-parser.js';
+import type { PersonaProfile } from '../persona/types.js';
+
+export interface PersonaAnswerDeps {
+  complete?: (prompt: string) => Promise<string>;
+}
+
+/** Resolve the registry mention first, then an exact display name. */
+export function resolvePersonaAddress(name: string, source: PersonaSource): PersonaProfile | null {
+  const mention = resolveMention(name, source);
+  if (mention) return mention;
+  const needle = name.replace(/^@/, '').toLocaleLowerCase();
+  return source.list().find((persona) => persona.displayName.toLocaleLowerCase() === needle) ?? null;
+}
+
+async function defaultComplete(prompt: string): Promise<string> {
+  const { streamLLM } = await import('../llm.js');
+  const { tierModel } = await import('../llm/model-defaults.js');
+  return streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('better') });
+}
+
+export async function answerAsPersona(persona: PersonaProfile, question: string, deps: PersonaAnswerDeps = {}): Promise<string> {
+  const prompt = `${persona.systemPrompt ?? `너는 ${persona.displayName} 이다`}\n\n## 질문\n${question}`;
+  const raw = await (deps.complete ?? defaultComplete)(prompt);
+  const answer = `@${persona.displayName}\n${raw.trim()}`;
+  const text = Array.from(answer).slice(0, 3_500).join('');
+  debug.log('persona.address', 'answered', { personaId: persona.personaId, chars: Array.from(text).length });
+  return text;
+}

package/src/intake-plane/runtime-callables.ts

@@ -305,7 +305,14 @@ export function buildRealIntakeCallables(
   };
 
   const decompose: DecomposeMemoCallable = (args) => promptCallable(args);
-  const categorize: CategorizeCallable = (args) => promptCallable(args);
+  const categorize: CategorizeCallable = async (args) => {
+    const text = await streamLLM([{ role: 'user', content: args.prompt }], () => {}, {
+      ...(args.provider ? { provider: providers[args.provider] } : {}),
+      ...(args.model ? { model: args.model } : {}),
+      ...(args.signal ? { signal: args.signal } : {}), usageRole: 'classify',
+    });
+    return { text, modelId: args.model };
+  };
   const align: AlignCallable = (args) => promptCallable(args);
 
   /** Synth callable — wraps R3 `synthWorkflowFromIntent`. Hands it a

package/src/intake-plane/telegram-seat-work.ts

@@ -1,11 +1,15 @@
 import { debug } from '../debug/log.js';
 import { telegramDecisionOwner } from '../decisions/telegram-decision-cards.js';
 import { canonicalSeatId } from '../msg/msg-store.js';
+import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../persona/global-registry.js';
+import type { PersonaSource } from '../persona/mention-parser.js';
 import { dispatchCeoTask, type CeoCommandDeps } from '../seat-dispatch/ceo-commands.js';
 import { ceoTaskDeps, classifyCeoIntent } from '../seat-dispatch/ceo-intent.js';
+import { askSeat, parseSeatAsk, type SeatAskDeps } from '../seat-dispatch/seat-ask.js';
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
 import { answerAsSeat } from './seat-answer.js';
+import { answerAsPersona, resolvePersonaAddress, type PersonaAnswerDeps } from './persona-answer.js';
 import {
   submitIntakeWork,
   type SubmitIntakeWorkDeps,
@@ -16,8 +20,12 @@ export interface TelegramSeatWorkDeps extends SubmitIntakeWorkDeps {
   submit?: typeof submitIntakeWork;
   config?: UserConfig;
   answer?: typeof answerAsSeat;
+  personaSource?: PersonaSource;
+  personaAnswer?: typeof answerAsPersona;
+  personaAnswerDeps?: PersonaAnswerDeps;
   dispatch?: typeof dispatchCeoTask;
   commandDeps?: CeoCommandDeps;
+  askDeps?: SeatAskDeps;
 }
 
 /** Addressed work preserves graph intake except for one owner's private seat request. */
@@ -38,6 +46,14 @@ export async function handleTelegramSeatWork(
     return result.reply;
   };
   if (!text.startsWith('@')) {
+    if (parseSeatAsk(text)) {
+      const auth = owner();
+      if (!auth) return null;
+      if (!deps.askDeps) throw new Error('seat ask delivery unavailable');
+      return askSeat(text, { channel: 'telegram', chatId: msg.chatId, messageId: msg.messageId,
+        ...(msg.threadId ? { threadId: msg.threadId } : {}), ...(msg.botId ? { botId: msg.botId } : {}) },
+      deps.commandDeps ?? ceoTaskDeps(auth.cfg, auth.id), deps.askDeps);
+    }
     if (!text.trim() || /^\s*[/@＠]/.test(text)) return null;
     const auth = owner();
     const configured = (auth?.cfg.raw?.seatDispatch as { defaultSeat?: unknown } | undefined)?.defaultSeat;
@@ -47,23 +63,41 @@ export async function handleTelegramSeatWork(
     const id = canonicalSeatId(seat.id);
     return ['OP', 'TC', 'MK', 'UX'].includes(id) ? sendTask(id, text, auth!.cfg, auth!.id) : null;
   }
-  const address = parseSeatAddress(text);
+  const address = parseSeatAddress(text.replace(/^(@[A-Za-z][A-Za-z0-9_-]*(?:,@?[A-Za-z][A-Za-z0-9_-]*)*)/, (prefix) => prefix.replaceAll(',@', ',')));
   if (!address) return null;
 
   const seats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
   const names = address.seats;
   debug.log('seat-address.telegram', 'parsed', { seats: names });
-  const unknown = seats.filter(({ seat }) => !seat).map(({ name }) => `@${name}`);
+  const hasUnresolved = seats.some(({ seat }) => !seat);
+  const auth = hasUnresolved ? owner() : null;
+  if (hasUnresolved && auth && !deps.personaSource) await awaitGlobalPersonaLoad();
+  const source = hasUnresolved && auth ? (deps.personaSource ?? getGlobalPersonaRegistry()) : null;
+  const addressed = seats.map(({ name, seat }) => ({
+    name, seat, persona: !seat && source ? resolvePersonaAddress(name, source) : null,
+  }));
+  const unknown = addressed.filter(({ seat, persona }) => !seat && (!persona || !auth)).map(({ name }) => `@${name}`);
   if (unknown.length) {
     debug.log('seat-address.telegram', 'rejected', { seats: names, reason: 'unknown-seat' });
     return `어느 좌석을 말씀하시나요? ${unknown.join(', ')}은(는) 등록된 좌석이 아닙니다. 좌석을 확인해 다시 보내 주세요.`;
   }
+  const personas = addressed.filter(({ persona }) => persona);
+  if (personas.length && addressed.length !== 1) {
+    debug.log('persona.address', 'rejected', { reason: 'mixed' });
+    return '페르소나는 한 번에 하나만 부를 수 있습니다';
+  }
   const body = address.body.trim();
   if (!body) {
     debug.log('seat-address.telegram', 'rejected', { seats: names, reason: 'empty-body' });
     return '어떤 일을 맡길까요? 좌석 주소 뒤에 요청 내용을 적어 다시 보내 주세요.';
   }
 
+  if (personas.length === 1 && personas[0]?.persona) {
+    const { name, persona } = personas[0];
+    debug.log('persona.address', 'resolved', { name, personaId: persona.personaId });
+    return (deps.personaAnswer ?? answerAsPersona)(persona, body, deps.personaAnswerDeps);
+  }
+
   if (seats.length === 1 && seats[0]?.seat) {
     const auth = owner();
     const seatId = canonicalSeatId(seats[0].seat.id);

package/src/intake-plane/wish-card.ts

@@ -0,0 +1,33 @@
+import { debug } from '../debug/log.js';
+import { CardStore } from '../task-cards/card-store.js';
+
+export function createWishCard(
+  { text, source, ref }: { text: string; source: 'telegram' | 'pwa' | 'tui'; ref: string },
+  store: CardStore = new CardStore(),
+): { cardId: string; title: string; created: boolean } {
+  const title = text.trim().split(/\r?\n/, 1)[0]!.trim().slice(0, 80);
+  if (!title) throw new Error('소원 글을 입력하세요');
+  if (!ref?.trim()) throw new Error('소원 참조가 필요합니다');
+  const goalId = `wish:${source}:${ref}`;
+  const old = store.listCards().find(card => card.goalId === goalId);
+  const card = old ?? store.createCard({ goalId, title });
+  const hasIntakeSection = card.sections.some(section => section.key === 'intake:wish:0');
+  const created = !old && !hasIntakeSection;
+  // A prior attempt may have created the card but stopped before writing its intake section. The card's first
+  // title wins: a retry with the same ref but a different request must not put a contradicting body on it
+  // (review must-fix) — keep the first title and record only that the retried text did not match.
+  if (!hasIntakeSection) {
+    const sameRequest = !old || title === card.title;
+    store.appendSection(card.id, {
+      key: 'intake:wish:0',
+      owner: 'steward',
+      content: JSON.stringify({
+        source, ref, title: card.title, text: sameRequest ? text : null, at: new Date().toISOString(),
+        ...(old ? { recovered: true } : {}), ...(sameRequest ? {} : { mismatch: true }),
+      }),
+    });
+    if (!sameRequest) debug.log('intake.wish', 'recovered-mismatch', { source, cardId: card.id });
+  }
+  debug.log('intake.wish', created ? 'created' : 'duplicate', { source, cardId: card.id });
+  return { cardId: card.id, title: card.title, created };
+}

package/src/intake-plane/wish-folder.ts

@@ -0,0 +1,67 @@
+import { readdirSync, readFileSync, statSync, type Dirent } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { CardStore } from '../task-cards/card-store.js';
+
+export interface WishScanResult {
+  added: number;
+  updated: number;
+  skipped: number;
+}
+
+/** Import markdown notes without writing to the Wish folder. The card event log retains intake revisions. */
+export function scanWishFolder({ dir, store }: { dir: string; store: CardStore }): WishScanResult {
+  let rootEntries: Dirent[];
+  try {
+    if (!statSync(dir).isDirectory()) throw new Error('not a directory');
+    rootEntries = readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if (error instanceof Error && (error.message === 'not a directory' ||
+      ('code' in error && (error.code === 'ENOENT' || error.code === 'ENOTDIR')))) {
+      throw new Error(`Wish 폴더를 찾지 못했습니다: ${dir}`);
+    }
+    throw error;
+  }
+
+  const paths: string[] = [];
+  const collect = (entries: typeof rootEntries, base: string) => {
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const path = join(base, entry.name);
+      if (entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'README.md') paths.push(path);
+    }
+  };
+  collect(rootEntries, dir);
+  for (const entry of rootEntries) {
+    if (entry.isDirectory() && !entry.name.startsWith('.')) {
+      const subdir = join(dir, entry.name);
+      collect(readdirSync(subdir, { withFileTypes: true }), subdir);
+    }
+  }
+  paths.sort();
+
+  const cards = new Map(store.listCards().map(card => [card.goalId, card]));
+  const result: WishScanResult = { added: 0, updated: 0, skipped: 0 };
+  for (const path of paths) {
+    const relPath = relative(dir, path).split('\\').join('/');
+    const goalId = `wish:${relPath}`;
+    const mtime = statSync(path).mtimeMs;
+    const old = cards.get(goalId);
+    const intakeSections = old?.sections.filter(section => section.key.startsWith('intake:wish:')) ?? [];
+    const lastIntake = intakeSections.at(-1);
+    if (lastIntake && JSON.parse(lastIntake.content).mtime === mtime) {
+      result.skipped++;
+      continue;
+    }
+    const title = /^# (.+)$/m.exec(readFileSync(path, 'utf8'))?.[1]?.trim() || basename(path, '.md');
+    const card = old ?? store.createCard({ goalId, title });
+    const intake = { source: 'wish', path: relPath, mtime, title };
+    store.appendSection(card.id, {
+      key: `intake:wish:${intakeSections.length}`,
+      owner: 'steward',
+      content: JSON.stringify(intake),
+    });
+    if (old) result.updated++;
+    else result.added++;
+  }
+  return result;
+}

package/src/intent-gate/gate.ts

@@ -21,8 +21,10 @@
 
 import { TaskStore } from '../task-orchestrator/store.js';
 import { createMission, listMissions, normalizeMissionSource, generateMissionSlug, type MissionSource } from '../autopilot/mission-registry.js';
-import { triageGoal, defaultTriageClassify, type TriageCallable } from '../autopilot/triage.js';
-import { resolveDomain, defaultDomainClassify, type DomainClassify } from '../autopilot/domain/resolve.js';
+import { triageGoal, isExecutionModel, type TriageCallable } from '../autopilot/triage.js';
+import { resolveDomain, buildDomainPrompt, type DomainClassify } from '../autopilot/domain/resolve.js';
+import { judge } from '../llm/judge-layer.js';
+import type { ResolveRoleProviderFn, StreamLlmFn } from '../intake-plane/runtime-callables.js';
 import { isDomain } from '../autopilot/domain/types.js';
 import { autoDecomposeMission, shouldPhaseDecompose } from '../autopilot/mission-engine.js';
 import { saveMissionOrigin, type MissionOrigin } from '../autopilot/mission-origin.js';
@@ -54,12 +56,14 @@ export interface SubmitIntentInput {
   origin?: MissionOrigin;
   /** id title 생성 seam(테스트 격리·luna 우회). 없으면 generateMissionSlug(luna) 디폴트. */
   slugFn?: (goal: string) => Promise<string>;
-  /** ★ triage 분류 seam(테스트 격리·luna 우회·2026-07-16). 없으면 defaultTriageClassify(luna) —
+  /** ★ triage 분류 seam(테스트 격리·luna 우회·2026-07-16). 없으면 classify 역할 judge —
    *  단 NODE_ENV=test 는 미주입(휴리스틱 baseline)으로 실 LLM 호출 방지. */
   triageClassify?: TriageCallable;
-  /** ★ 도메인 분류 seam(테스트 격리·luna 우회·2026-07-20). 없으면 defaultDomainClassify(luna) —
+  /** ★ 도메인 분류 seam(테스트 격리·luna 우회·2026-07-20). 없으면 classify 역할 judge —
    *  단 NODE_ENV=test 는 미주입(키워드 baseline)으로 실 LLM 호출 방지. */
   domainClassify?: DomainClassify;
+  /** Injectable transport for testing the production judge path without network access. */
+  judgeDeps?: { streamLLM: StreamLlmFn; resolveRoleProvider: ResolveRoleProviderFn };
 }
 
 export type SubmitIntentResult =
@@ -132,14 +136,30 @@ export async function submitIntent(input: SubmitIntentInput): Promise<SubmitInte
     // 도메인 맥락 해소(§3.8·D5) — 키워드가 모호하면 최근 미션 도메인으로 기울인다
     // ("반도체 조사"→최근 투자 활동이면 investment). high 면 키워드 그대로.
     const recentDomains = listMissions(store, { limit: 8 }).map((r) => r.domain).filter(isDomain);
-    // ★ triage(luna 주도·tier semantic 판정) + 도메인 해소 + LLM(luna) slug 를 병렬로(hot-path 무증가).
-    //   triageClassify 미주입 & test 면 휴리스틱 baseline(실 LLM 우회). 운영은 defaultTriageClassify(luna).
+    // ★ triage(classify 역할·tier semantic 판정) + 도메인 해소 + LLM slug 를 병렬로(hot-path 무증가).
+    //   triageClassify 미주입 & test 면 휴리스틱 baseline(실 LLM 우회).
     const triageClassify = input.triageClassify
-      ?? (process.env.NODE_ENV === 'test' ? undefined : defaultTriageClassify);
-    // ★ 도메인도 luna 승격(2026-07-20) — 키워드는 주제 vs 행위유형을 못 갈라 "요약 기능 구현" 을
-    //   business(리서치·PR없음)로 오라우팅. luna 가 semantic 판정(강앵커 high 는 키워드 신뢰).
+      ?? (process.env.NODE_ENV === 'test' && !input.judgeDeps ? undefined : async (prompt: string) => {
+        const decision = await judge({ site: 'intent.triage', prompt, ...input.judgeDeps, schema: (value) => {
+          if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+          const row = value as Record<string, unknown>;
+          if (!isExecutionModel(row.executionModel) || (row.tier !== 'light' && row.tier !== 'heavy') ||
+            (row.rationale !== undefined && typeof row.rationale !== 'string')) return null;
+          return row;
+        } });
+        return decision.ok ? JSON.stringify(decision.value) : '';
+      });
+    // ★ 도메인도 의미 판정(2026-07-20) — 키워드는 주제 vs 행위유형을 못 갈라 "요약 기능 구현" 을
+    //   business(리서치·PR없음)로 오라우팅. judge 가 semantic 판정(강앵커 high 는 키워드 신뢰).
     const domainClassify = input.domainClassify
-      ?? (process.env.NODE_ENV === 'test' ? undefined : defaultDomainClassify);
+      ?? (process.env.NODE_ENV === 'test' && !input.judgeDeps ? undefined : async (goal, ctx) => {
+        const decision = await judge({ site: 'intent.domain', prompt: buildDomainPrompt(goal, ctx), ...input.judgeDeps, schema: (value) => {
+          if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+          const domain = (value as Record<string, unknown>).domain;
+          return isDomain(domain) ? domain : null;
+        } });
+        return decision.ok ? decision.value : null;
+      });
     const [resolved, slug, triage] = await Promise.all([
       resolveDomain(marker.goal, { recentDomains, classify: domainClassify }),
       (input.slugFn ?? generateMissionSlug)(marker.goal),

package/src/live/detail-switch.ts

@@ -13,6 +13,7 @@ import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
+import { publishInsideEvent } from '../nexus/api/inside-events.js';
 import { prodInstanceRoot } from '../instance/resolve.js';
 
 export const LIVE_DETAIL_DEFAULT_TTL_MIN = 30;
@@ -170,6 +171,10 @@ export function emitDecision(event: DecisionEvent, opts: DetailReadOptions = {})
     ...(parentRunId ? { parentRunId } : {}),
     ...(shard ? { shard } : {}),
   });
+  publishInsideEvent({ kind: 'pty.decision', decisionKind: event.kind, what: event.what,
+    reason: event.reason, purpose: event.purpose, target: event.target,
+    ...(runId ? { runId } : {}), ...(event.phase ? { phase: event.phase } : {}),
+    ...(parentRunId ? { parentRunId } : {}), ...(shard ? { shard } : {}) });
   return true;
 }
 

package/src/llm/difficulty.ts

@@ -0,0 +1,57 @@
+import { markdownSection, parseGoalType, tracedPathReferences, verbatimOriginalAsk } from '../self-implement/goal-author.js';
+import { lookupLlmTierSpec } from '../model-tier/llm-tier-map.js';
+import type { GoalType } from '../self-implement/goal-author.js';
+import type { ModelTier } from '../model-tier/types.js';
+import { ROLE_MODEL_DEFAULTS, type RoleLlmResolution } from '../user-config.js';
+
+export interface DifficultySignals {
+  targetPathCount: number;
+  decisionSignalCount: number;
+  expectedChangedFileCount: number | null;
+  goalType: GoalType | null;
+}
+
+export type DifficultyLevel = 'small' | 'medium' | 'large';
+
+/** Count declared target paths and authored decision signals without counting quoted run history. */
+export function goalDifficultySignals(document: string): DifficultySignals {
+  const ask = verbatimOriginalAsk(document);
+  const targetLine = (ask ?? document).split(/\r?\n/)
+    .map((line) => /^대상 경로:\s*(.+)$/.exec(line)?.[1])
+    .find((line) => line !== undefined);
+  const namedPaths = targetLine?.split(' · ').map((path) => path.trim().replace(/^`|`$/g, '')).filter(Boolean) ?? [];
+  const paths = namedPaths.length ? namedPaths : tracedPathReferences(document).map(({ path }) => path);
+  const signals = markdownSection(document, '판정 신호') ?? '';
+  const candidates = signals.split(/\r?\n/).filter((line) => /^\s*- Candidate decision signal:\s*$/.test(line)).length;
+  const expectedResults = signals.split(/\r?\n/).filter((line) => /^\s*- Expected result:\s*\S/.test(line)).length;
+  const countLine = (ask ?? document).split(/\r?\n/).find((line) => /^\s*(?:-\s*)?(?:예상 (?:변경|바뀌는) 파일 수|Expected changed files(?: count)?):\s*\d+\s*$/i.test(line));
+  const expectedChangedFileCount = countLine ? Number(countLine.split(':').at(-1)!.trim()) : null;
+  return {
+    targetPathCount: new Set(paths).size,
+    decisionSignalCount: Math.max(candidates, expectedResults),
+    expectedChangedFileCount,
+    goalType: parseGoalType(document),
+  };
+}
+
+export function classifyGoalDifficulty(signals: DifficultySignals): DifficultyLevel {
+  const { targetPathCount, decisionSignalCount, expectedChangedFileCount, goalType } = signals;
+  if (targetPathCount > 5 || decisionSignalCount > 5 || (expectedChangedFileCount ?? 0) > 5) return 'large';
+  if (goalType === 'implement' && targetPathCount === 1 && decisionSignalCount === 1) return 'small';
+  return 'medium';
+}
+
+/** Only the baseline role default is adjustable; explicit roleLlm and older config/env layers win. */
+export function implementDifficultyTier(level: DifficultyLevel, role: RoleLlmResolution): ModelTier | undefined {
+  if (role.source !== 'default') return undefined;
+  return level === 'small' ? 'budget' : level === 'large' ? 'best' : ROLE_MODEL_DEFAULTS.implement.tier;
+}
+
+export function resolveImplementDifficulty(role: RoleLlmResolution, level: DifficultyLevel): RoleLlmResolution {
+  const tier = implementDifficultyTier(level, role);
+  return tier === undefined ? role : {
+    ...role,
+    model: lookupLlmTierSpec(role.provider, tier).model,
+    tier,
+  };
+}

package/src/llm/judge-layer.ts

@@ -0,0 +1,101 @@
+import { debug } from '../debug/log.js';
+import { resolveRoleLlm, type UserConfig } from '../user-config.js';
+import type { ResolveRoleProviderFn, StreamLlmFn } from '../intake-plane/runtime-callables.js';
+
+interface JudgeReply {
+  text: string;
+  promptTokens?: number;
+  completionTokens?: number;
+  costUsd?: number;
+  modelId?: string;
+}
+
+interface JudgeOptions<T = string> {
+  site: string;
+  prompt: string;
+  messages?: Array<{ role: 'user' | 'system' | 'assistant'; content: string }>;
+  /** Return null when the parsed decision is not usable. */
+  schema?: (value: unknown) => T | null;
+  signal?: AbortSignal;
+  /** Injectable transport for callers with an existing LLM callable. */
+  call?: (args: { prompt: string; signal?: AbortSignal; provider: string; model: string }) => Promise<JudgeReply>;
+  streamLLM?: StreamLlmFn;
+  resolveRoleProvider?: ResolveRoleProviderFn;
+  /** Optional config slice for deterministic role resolution in isolated callers. */
+  config?: UserConfig;
+}
+
+type JudgeResult<T> =
+  | { ok: true; value: T; reply: JudgeReply; provider: string; model: string }
+  | { ok: false; reason: 'call'; error: unknown }
+  | { ok: false; reason: 'schema'; rawText: string };
+
+/** Marks a judge call that ran on an injected transport with no configured provider. */
+export const UNRESOLVED = 'unresolved';
+
+function parseJson(text: string): unknown {
+  const trimmed = text.trim();
+  const fence = trimmed.match(/```(?:json)?\s*\n([\s\S]*?)```/);
+  const candidate = fence ? fence[1]!.trim() : trimmed;
+  try { return JSON.parse(candidate); } catch { /* Models can prefix a JSON object with prose. */ }
+  const start = candidate.indexOf('{');
+  const end = candidate.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  try { return JSON.parse(candidate.slice(start, end + 1)); } catch { return null; }
+}
+
+/** One role-scoped classification call; errors and invalid decisions leave rule fallback to the caller. */
+export async function judge<T = string>(opts: JudgeOptions<T>): Promise<JudgeResult<T>> {
+  const started = Date.now();
+  let provider = '';
+  let model = '';
+  let ok = false;
+  try {
+    const picked = opts.resolveRoleProvider?.('classify');
+    if (picked) {
+      provider = picked.provider.name;
+      model = picked.model ?? '';
+    } else {
+      try {
+        const resolved = resolveRoleLlm('classify', opts.config ? { config: opts.config } : {});
+        provider = resolved.provider;
+        model = resolved.model;
+      } catch (error) {
+        // An injected transport does not need a configured provider; a real call still fails as before.
+        if (!opts.call || (error as Error | undefined)?.name !== 'NoLlmProviderAvailableError') throw error;
+        provider = UNRESOLVED;
+        model = UNRESOLVED;
+        try { debug.log('llm.judge', 'provider-unresolved', { site: opts.site }); } catch { /* fail-soft */ }
+      }
+    }
+    const messages = opts.messages ?? [{ role: 'user' as const, content: opts.prompt }];
+    let reply: JudgeReply;
+    if (opts.call) {
+      reply = await opts.call({ prompt: opts.prompt, signal: opts.signal, provider, model });
+    } else {
+      const llm = picked && opts.streamLLM ? undefined : await import('../llm.js');
+      const transportProvider = picked?.provider ?? llm?.PROVIDERS[provider];
+      if (!transportProvider) throw new Error(`Unknown classify provider: ${provider}`);
+      const streamOpts = { ...(model ? { model } : {}), ...(opts.signal ? { signal: opts.signal } : {}), usageRole: 'classify' as const };
+      if (opts.streamLLM) {
+        reply = { text: await opts.streamLLM(messages, () => {}, {
+          ...streamOpts, provider: transportProvider as ReturnType<ResolveRoleProviderFn>['provider'],
+        }) };
+      } else {
+        const registeredProvider = llm?.PROVIDERS[provider];
+        if (!llm || !registeredProvider) throw new Error(`Unknown classify provider: ${provider}`);
+        reply = { text: await llm.streamLLM(messages, () => {}, { ...streamOpts, provider: registeredProvider }) };
+      }
+    }
+    const value = opts.schema ? opts.schema(parseJson(reply.text)) : reply.text as T;
+    if (value === null || value === undefined) return { ok: false, reason: 'schema', rawText: reply.text };
+    ok = true;
+    return { ok: true, value, reply, provider, model };
+  } catch (error) {
+    return { ok: false, reason: 'call', error };
+  } finally {
+    try {
+      debug.log('llm.judge', 'call', { site: opts.site, provider, model, ms: Date.now() - started, ok });
+    } catch { /* Observation must not turn an undecided call into an exception. */ }
+  }
+}