elanous 0.2.9 → 0.2.11

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

@@ -1,5 +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,
@@ -8,32 +18,98 @@ import type { TelegramWorkMessage } from './telegram-work.js';
 
 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 Telegram work goes through graph intake, not the chat turn. */
+/** Addressed work preserves graph intake except for one owner's private seat request. */
 export async function handleTelegramSeatWork(
   text: string,
   msg: TelegramWorkMessage,
   deps: TelegramSeatWorkDeps = {},
 ): Promise<string | null> {
-  if (!text.startsWith('@')) return null;
-  const address = parseSeatAddress(text);
+  const owner = (): { cfg: UserConfig; id: string } | null => {
+    if (msg.userId === undefined || String(msg.chatId) !== String(msg.userId)) return null;
+    const cfg = deps.config ?? getUserConfig();
+    const id = telegramDecisionOwner(cfg);
+    return id && id === String(msg.userId) ? { cfg, id } : null;
+  };
+  const sendTask = async (seat: string, body: string, cfg: UserConfig, id: string): Promise<string> => {
+    const result = await (deps.dispatch ?? dispatchCeoTask)(seat, body, deps.commandDeps ?? ceoTaskDeps(cfg, id), { via: 'telegram' });
+    debug.log('seat.dispatch', 'intent', { seat, intent: 'task', via: 'telegram', outcome: result.channel });
+    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;
+    if (typeof configured !== 'string' || classifyCeoIntent(text) !== 'task') return null;
+    const seat = resolveSeat(configured);
+    if (!seat) return null;
+    const id = canonicalSeatId(seat.id);
+    return ['OP', 'TC', 'MK', 'UX'].includes(id) ? sendTask(id, text, auth!.cfg, auth!.id) : null;
+  }
+  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);
+    if (auth && ['OP', 'TC', 'MK', 'UX'].includes(seatId)) {
+      const intent = classifyCeoIntent(body);
+      if (intent === 'task') return sendTask(seatId, body, auth.cfg, auth.id);
+      const answer = await (deps.answer ?? answerAsSeat)(seats[0].name, body);
+      debug.log('seat.dispatch', 'intent', { seat: seatId, intent, via: 'telegram', outcome: answer ? 'answered' : 'intake' });
+      if (answer) return answer.text;
+    }
+  }
+
   const reportTo = {
     channel: 'telegram' as const,
     chatId: msg.chatId,

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

@@ -13,6 +13,7 @@ import {
 
 export interface TelegramWorkMessage {
   chatId: number;
+  userId?: number;
   messageId: number;
   botId?: string;
   threadId?: number;

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' ? 'better' : 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. */ }
+  }
+}

package/src/llm/mission-router.ts

@@ -5,10 +5,9 @@
 // mission. Tier 1 is a pure heuristic — Korean + English regex over
 // the input plus attachment + length signals. No I/O, no network.
 //
-// Tier 2 (local LLM grammar-constrained classifier · P1-3) and Tier 3
-// (cloud LLM · deferred) plug into this same `MissionRouter` interface
-// via composition — the predict() implementation is replaced at
-// factory time, the public surface stays stable so consumers
+// Tier 2 (injected LLM classifier · P1-3) uses the classify-role judge layer.
+// Tier 3 (cloud LLM · deferred) can plug into this same `MissionRouter` interface;
+// the public surface stays stable so consumers
 // (`elanous/route/predict` envelope · iOS chip · …) don't churn.
 //
 // Default mission → provider map mirrors the ROADMAP §3.1 table:
@@ -23,6 +22,8 @@
 // flow through MissionRoutingConfig — pass the user-config slice into
 // createMissionRouter({ config }) at boot.
 
+import { judge } from './judge-layer.js';
+
 export type MissionKind = 'plan' | 'build' | 'review' | 'research' | 'quick' | 'vision';
 
 export type MissionAttachmentKind = 'image' | 'audio' | 'video' | 'document';
@@ -211,7 +212,7 @@ function resolveEntry(
   return { provider: DEFAULT_PROVIDER[mission], model: DEFAULT_MODEL[mission] };
 }
 
-/** Tier 2 seam — local LLM classifier (P1-3). When confidence from
+/** Tier 2 seam — injected LLM classifier (P1-3). When confidence from
  *  Tier 1 drops below TIER2_THRESHOLD the router calls this client
  *  to refine the mission with a grammar-constrained 1-token
  *  prediction. Implementations are pluggable — the substrate today
@@ -219,14 +220,18 @@ function resolveEntry(
  *  src/background-reasoning/local-llm-process.ts; a future PR wires
  *  the qwen-2.5 grammar path through.
  *
- *  Contract: respond with one of the 6 MissionKind strings + a
- *  confidence in [0, 1]. Throw on unrecoverable error; the router
+ *  Contract: classify with the supplied classify-role provider/model,
+ *  respond with one of the 6 MissionKind strings + a confidence in [0, 1].
+ *  Throw on unrecoverable error; the router
  *  swallows and falls back to Tier 1. */
 export interface MissionLocalLLMClient {
   classify(input: {
     text: string;
     attachments?: ReadonlyArray<MissionAttachment>;
-  }): Promise<{ mission: MissionKind; confidence: number }>;
+    /** The classify-role selection the client must use. */
+    provider: string;
+    model: string;
+  }): Promise<{ mission: MissionKind; confidence: number; /** The model actually used — must equal the requested one or the decision is discarded. */ model?: string }>;
 }
 
 export const TIER2_CONFIDENCE_THRESHOLD = 0.6;
@@ -320,18 +325,27 @@ export function createMissionRouter(opts?: {
           confidence = cached.confidence;
           tier = 2;
         } else {
-          try {
-            const refined = await localLLM.classify({
-              text: input.text ?? '',
-              attachments: input.attachments,
-            });
-            cache.set(key, refined, now());
-            mission = refined.mission;
-            confidence = refined.confidence;
+          const decision = await judge({
+            site: 'llm.mission-router', prompt: JSON.stringify({ text: input.text ?? '', attachments: input.attachments ?? [] }),
+            call: async ({ provider, model }) => {
+              const refined = await localLLM.classify({ text: input.text ?? '', attachments: input.attachments, provider, model });
+              // Enforce the classify-role model: a client that ignored it (or can't say) doesn't get to decide.
+              return { text: refined.model === model && model ? JSON.stringify(refined) : 'null', modelId: refined.model };
+            },
+            schema: (value) => {
+              if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+              const row = value as Record<string, unknown>;
+              if (typeof row.mission !== 'string' || !Object.hasOwn(DEFAULT_PROVIDER, row.mission) ||
+                  typeof row.confidence !== 'number' || !Number.isFinite(row.confidence) ||
+                  row.confidence < 0 || row.confidence > 1) return null;
+              return { mission: row.mission as MissionKind, confidence: row.confidence };
+            },
+          });
+          if (decision.ok) {
+            cache.set(key, decision.value, now());
+            mission = decision.value.mission;
+            confidence = decision.value.confidence;
             tier = 2;
-          } catch {
-            // Swallow · keep Tier 1 result. classifier hiccup
-            // shouldn't stall the input chip.
           }
         }
       }

package/src/loops/contract/examples/cmo-seat.loop.yaml

@@ -0,0 +1,51 @@
+id: cmo-seat
+version: 1.0.0
+kind: seat
+role: docs/roles/MK.md
+graph: graphs/operate-loop.yaml
+cadence:
+  timezone: Asia/Seoul
+  byDefcon:
+    - {defcon: 5, everyMinutes: 1440}
+    - {defcon: 4, everyMinutes: 720}
+    - {defcon: 3, everyMinutes: 240}
+    - {defcon: 2, everyMinutes: 60}
+    - {defcon: 1, everyMinutes: 15}
+posture:
+  default: 5
+  levels:
+    - {defcon: 5, minResolution: L0, maxResolution: L2, budget: &normal {maxTokens: 6000, maxToolCalls: 6, maxCostUsd: 0.4}}
+    - {defcon: 4, minResolution: L0, maxResolution: L2, budget: *normal}
+    - {defcon: 3, minResolution: L1, maxResolution: L3, budget: &urgent {maxTokens: 12000, maxToolCalls: 12, maxCostUsd: 0.8}}
+    - {defcon: 2, minResolution: L1, maxResolution: L3, budget: *urgent}
+    - {defcon: 1, minResolution: L1, maxResolution: L3, budget: *urgent}
+  raiseOn: [{event: mk-checklist-red-or-request-urgent, afterTicks: 1}]
+  lowerOn: [{event: mk-backlog-clear, afterTicks: 2}]
+  hysteresis: {minDwellMinutes: 120, clearTicks: 2}
+resolution:
+  default: L0
+  steps:
+    - {level: L0, grounding: [], budget: &scan {maxTokens: 1500, maxToolCalls: 2, maxCostUsd: 0.1}}
+    - {level: L1, grounding: [{tool: omni-digest, budget: *scan}], budget: *normal}
+    - {level: L2, grounding: [{tool: omni-crawl, budget: *normal}], budget: *urgent}
+    - {level: L3, grounding: [{tool: social-pulse, budget: *scan}, {tool: aside-repl, budget: *normal}], budget: *urgent}
+  raiseOn: {event: campaign-anomaly, afterTicks: 1}
+  lowerOn: {event: verified-campaign-outcome, afterTicks: 2}
+grounding: [omni-digest, omni-crawl, social-pulse, aside-repl]
+memory:
+  local: {ledger: seat-loop/MK/YYYY-MM-DD.jsonl, working: loop/cmo-seat/context}
+  promotesTo: [self-recall, decisions, checklist]
+  retention: {workingDays: 7, ledgerDays: 90}
+neighbors:
+  - {id: op-seat, exchange: [status, request, decision, blocked], heartbeat: {everyMinutes: 1440, missedTicks: 2}, onAbsent: {action: defer, delegateTo: orchestrator}}
+  - {id: ux-seat, exchange: [status, request, blocked], heartbeat: {everyMinutes: 1440, missedTicks: 2}, onAbsent: {action: defer, delegateTo: orchestrator}}
+  - {id: tc-seat, exchange: [status, request, blocked], heartbeat: {everyMinutes: 1440, missedTicks: 2}, onAbsent: {action: defer, delegateTo: orchestrator}}
+spawn:
+  allowed: [harness]
+  max: 1
+  reap: {afterMinutes: 120, onExit: reconcile}
+hitl: {ladder: [self-heal, neighbor, orchestrator, human]}
+budget: *urgent
+observability:
+  category: loop.cmo-seat
+  events: [tick, posture-change, resolution-change, grounding, heartbeat, absent, exchange, spawn, reap, promote, hitl]

package/src/loops/contract/examples/orchestrator.loop.yaml

@@ -0,0 +1,57 @@
+id: orchestrator
+version: 1.0.0
+kind: orchestrator
+role: docs/roles/OP.md
+graph: graphs/operate-loop.yaml
+orchestration:
+  windows:
+    - {at: '08:00', delegateTo: [op-seat, cmo-seat, tc-seat, ux-seat], fromLedger: release/checklist-and-seat-requests}
+    - {at: '12:00', delegateTo: [op-seat, cmo-seat, tc-seat, ux-seat], fromLedger: seat-loop/status-and-decisions}
+    - {at: '18:00', delegateTo: [op-seat, cmo-seat, tc-seat, ux-seat], fromLedger: release/landings-and-blockers}
+cadence:
+  timezone: Asia/Seoul
+  byDefcon:
+    - {defcon: 5, everyMinutes: 120}
+    - {defcon: 4, everyMinutes: 60}
+    - {defcon: 3, everyMinutes: 30}
+    - {defcon: 2, everyMinutes: 15}
+    - {defcon: 1, everyMinutes: 5}
+posture:
+  default: 5
+  levels:
+    - {defcon: 5, minResolution: L0, maxResolution: L2, budget: &normal {maxTokens: 8000, maxToolCalls: 8, maxCostUsd: 0.5}}
+    - {defcon: 4, minResolution: L0, maxResolution: L2, budget: *normal}
+    - {defcon: 3, minResolution: L1, maxResolution: L3, budget: &urgent {maxTokens: 16000, maxToolCalls: 16, maxCostUsd: 1}}
+    - {defcon: 2, minResolution: L1, maxResolution: L3, budget: *urgent}
+    - {defcon: 1, minResolution: L1, maxResolution: L3, budget: *urgent}
+  raiseOn: [{event: release-red-or-neighbor-blocked, afterTicks: 1}]
+  lowerOn: [{event: all-seats-clear, afterTicks: 2}]
+  hysteresis: {minDwellMinutes: 60, clearTicks: 2}
+resolution:
+  default: L0
+  steps:
+    - {level: L0, grounding: [], budget: &scan {maxTokens: 2000, maxToolCalls: 2, maxCostUsd: 0.1}}
+    - {level: L1, grounding: [{tool: omni-digest, budget: *scan}], budget: *normal}
+    - {level: L2, grounding: [{tool: omni-crawl, budget: *normal}, {tool: aside-repl, budget: *scan}], budget: *urgent}
+    - {level: L3, grounding: [{tool: social-pulse, budget: *scan}, {tool: omni-crawl, budget: *normal}], budget: *urgent}
+  raiseOn: {event: new-anomaly-or-unknown, afterTicks: 1}
+  lowerOn: {event: evidence-stable, afterTicks: 2}
+grounding: [omni-digest, omni-crawl, aside-repl, social-pulse]
+memory:
+  local: {ledger: loop/orchestrator/events, working: loop/orchestrator/context}
+  promotesTo: [self-recall, decisions, checklist]
+  retention: {workingDays: 7, ledgerDays: 90}
+neighbors:
+  - {id: op-seat, exchange: [status, request, decision, blocked], heartbeat: {everyMinutes: 120, missedTicks: 2}, onAbsent: {action: delegate, delegateTo: steward}}
+  - {id: cmo-seat, exchange: [status, request, blocked], heartbeat: {everyMinutes: 120, missedTicks: 2}, onAbsent: {action: defer, delegateTo: orchestrator}}
+  - {id: tc-seat, exchange: [status, request, blocked], heartbeat: {everyMinutes: 120, missedTicks: 2}, onAbsent: {action: escalate, delegateTo: orchestrator}}
+  - {id: ux-seat, exchange: [status, request, blocked], heartbeat: {everyMinutes: 120, missedTicks: 2}, onAbsent: {action: defer, delegateTo: orchestrator}}
+spawn:
+  allowed: [agent, harness]
+  max: 4
+  reap: {afterMinutes: 120, onExit: reconcile}
+hitl: {ladder: [self-heal, neighbor, orchestrator, human]}
+budget: *urgent
+observability:
+  category: loop.orchestrator
+  events: [tick, posture-change, resolution-change, grounding, heartbeat, absent, exchange, spawn, reap, promote, hitl]