elanous 0.2.40 → 0.2.42

package/src/loops/orchestrator/coordinator-shadow.ts

@@ -0,0 +1,226 @@
+/**
+ * COORD-ENTRANCE-FOLD · 0.2.42 칸 · TASK-AGENT(OP 디스패처) — 셸 디스패처 은퇴 결정 카드.
+ *
+ * 배경: 대표 10-19 «중간층(런 닥터 r3·rework · 입구 디스패처)이 0.2.35 최우선 병목» ·
+ * seat-state/OP/PLAN-mid-tier-loops-2026-10-19.md §5.
+ *
+ * 판정 신호: 조율자 그림자가 ④ 빌더로 같은 칸·같은 지시서를 달력 기준 3일 연속
+ * 디스패치하면 «셸 디스패처 은퇴» 결정 카드를 기존 결정 원장(src/decisions/decision-ledger.ts,
+ * `decisions/decisions.jsonl`) 부가 형식 그대로 정확히 1장 올린다.
+ *
+ * 그림자 디스패치 원장(<root>/seat-state/OP/coordinator-shadow-dispatch.jsonl)은
+ * 조율자 그림자 디스패처가 한 줄씩 적는 JSONL 이다:
+ *   {"date":"2026-03-02","agent":"builder-4","cell":"src/x/y.ts","directive":"DIR-123"}
+ * (별칭 허용: date=day · agent=target · cell=lane · directive=directiveId)
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { DecisionLedger } from '../../decisions/decision-ledger.js';
+import { withFileLockSync } from '../../storage/file-lock.js';
+import { findGitDir } from '../../git-fs/locate.js';
+
+export interface CoordinatorShadowDispatch {
+  /** 달력 날짜(YYYY-MM-DD, 생산 기록은 UTC ISO 날짜). */
+  date: string;
+  /** 대상 에이전트(예: builder-4). */
+  agent: string;
+  /** 작업을 받은 과제 소유 seat (`tasks hand --seat`). */
+  recipient?: string;
+  /** 칸(대상 경로). */
+  cell: string;
+  /** 지시서 id. */
+  directive: string;
+}
+
+export interface CoordinatorShadowStreak {
+  agent: string;
+  recipient?: string;
+  cell: string;
+  directive: string;
+  /** 연속을 이룬 세 달력 날짜(직전2일·오늘, 오름차순). */
+  dates: [string, string, string];
+}
+
+export interface CoordinatorShadowTickOptions {
+  /** 저장소/worktree 루트 — 그림자 디스패치 원장 기준 경로. 생산 기본: cwd 트리. */
+  root?: string;
+  /** 결정 원장 stateDir. 생산 기본: elanousStateRoot(). */
+  stateDir?: string;
+  /** 시계 주입(생산: 실제 Date). */
+  now?: () => Date;
+  /** 원장 행 직접 주입(시험용 — 생산 호출 경로는 그대로 지나간다). */
+  dispatches?: CoordinatorShadowDispatch[];
+}
+
+export interface CoordinatorShadowTickResult {
+  /** 판정 기준일(YYYY-MM-DD). */
+  checked: string;
+  evidence: CoordinatorShadowStreak | null;
+  /** 올라간(또는 이미 있던) 결정 카드 id. */
+  cardId?: string;
+  /** 같은 스탬프(칸+지시서+마지막 날) 카드가 이미 있어 1장만 유지됐을 때. */
+  skipped?: 'duplicate';
+}
+
+/** 그림자 디스패치 원장 생산 기본 경로. */
+export function coordinatorShadowJournalPath(root: string): string {
+  return join(root, 'seat-state', 'OP', 'coordinator-shadow-dispatch.jsonl');
+}
+
+/** Resolve the containing checkout when the CLI was started from a repository subdirectory. */
+export function resolveCoordinatorShadowRoot(cwd = process.cwd()): string {
+  return findGitDir(cwd)?.root ?? cwd;
+}
+
+/** launcher가 work-order를 받아들인 뒤 그림자 근거만 덧붙인다. 발사 결정·인자는 읽거나 바꾸지 않는다. */
+export function recordCoordinatorShadowDispatch(
+  root: string,
+  row: CoordinatorShadowDispatch,
+): void {
+  const path = coordinatorShadowJournalPath(root);
+  mkdirSync(dirname(path), { recursive: true });
+  withFileLockSync(`${path}.lock`, () => appendFileSync(path, `${JSON.stringify(row)}\n`));
+}
+
+/** ④ 빌더 판별 — «빌더④» «④빌더» «builder-4» «builder_4» «builder 4» «b4» 계열을 받는다. */
+function fourthBuilderAgentKey(agent: string): string | null {
+  const key = agent.normalize('NFC').replace(/\s+/g, '').toLowerCase();
+  return /^(?:builder|b)[-_]?4$/.test(key) || /^④?빌더4$/.test(key) || key === '④빌더' || key === '빌더④'
+    ? 'builder-4'
+    : null;
+}
+
+export function isFourthBuilderAgent(agent: string): boolean {
+  return fourthBuilderAgentKey(agent) !== null;
+}
+
+function shiftDay(isoDay: string, delta: number): string {
+  const date = new Date(`${isoDay}T00:00:00Z`);
+  date.setUTCDate(date.getUTCDate() + delta);
+  return date.toISOString().slice(0, 10);
+}
+
+const DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * 조율자 그림자 디스패치 기록에서 오늘과 직전 2일치를 읽어,
+ * 대상이 ④ 빌더이고 칸·지시서가 같은 달력 기준 3일 연속인 모든 쌍을 반환한다.
+ * 연속 끊김(칸·지시서·대상이 다르거나 하루 무디스패치)이면 해당 streak 는 성립하지 않는다.
+ */
+export function detectBuilderThreeDayStreak(
+  dispatches: readonly CoordinatorShadowDispatch[],
+  today: string,
+): CoordinatorShadowStreak | null {
+  return detectBuilderThreeDayStreaks(dispatches, today)[0] ?? null;
+}
+
+/** 오늘의 3일 창에서 모든 적격 (agent, cell, directive) 쌍을 돌려 각 쌍의 카드를 독립 판정한다. */
+export function detectBuilderThreeDayStreaks(
+  dispatches: readonly CoordinatorShadowDispatch[],
+  today: string,
+): CoordinatorShadowStreak[] {
+  if (!DAY_PATTERN.test(today)) throw new Error(`calendar day required: ${today}`);
+  const window: [string, string, string] = [shiftDay(today, -2), shiftDay(today, -1), today];
+  const groups = new Map<string, { agent: string; recipient?: string; recipientDate?: string; cell: string; directive: string; days: Set<string> }>();
+  for (const row of dispatches) {
+    if (!row || typeof row.date !== 'string' || !DAY_PATTERN.test(row.date)) continue;
+    const builderKey = fourthBuilderAgentKey(String(row.agent ?? ''));
+    if (!builderKey) continue;
+    const recipient = typeof row.recipient === 'string' ? row.recipient : undefined;
+    const cell = String(row.cell ?? '');
+    const directive = String(row.directive ?? '');
+    if (!cell || !directive) continue;
+    const key = `${builderKey}\u0000${cell}\u0000${directive}`;
+    const group = groups.get(key) ?? { agent: row.agent, cell, directive, days: new Set<string>() };
+    if (recipient && window.includes(row.date as typeof window[number])
+      && (!group.recipientDate || row.date >= group.recipientDate)) {
+      group.recipient = recipient;
+      group.recipientDate = row.date;
+    }
+    group.days.add(row.date);
+    groups.set(key, group);
+  }
+  const keys = [...groups.keys()].sort();
+  return keys.flatMap(key => {
+    const group = groups.get(key)!;
+    return window.every(day => group.days.has(day))
+      ? [{ agent: group.agent, ...(group.recipient ? { recipient: group.recipient } : {}), cell: group.cell, directive: group.directive, dates: [...window] as [string, string, string] }]
+      : [];
+  });
+}
+
+function readDispatchJournal(path: string): CoordinatorShadowDispatch[] {
+  if (!existsSync(path)) return [];
+  const rows: CoordinatorShadowDispatch[] = [];
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    let raw: Record<string, unknown>;
+    try { raw = JSON.parse(line) as Record<string, unknown>; } catch { continue; }
+    // JSON.parse 가 성공하는 비객체 행(`null`·스칼라 등)도 파손 행이다 — 판독에서 건너뛴다.
+    if (typeof raw !== 'object' || raw === null) continue;
+    const date = raw.day ?? raw.date;
+    const agent = raw.target ?? raw.agent;
+    const recipient = raw.recipient ?? raw.seat;
+    const cell = raw.lane ?? raw.cell;
+    const directive = raw.directiveId ?? raw.directive;
+    if (typeof date === 'string' && typeof agent === 'string' && typeof cell === 'string' && typeof directive === 'string') {
+      rows.push({ date, agent, ...(typeof recipient === 'string' ? { recipient } : {}), cell, directive });
+    }
+  }
+  return rows;
+}
+
+/** «셸 디스패처 은퇴» 결정 카드의 영구 idempotency ref(같은 칸+지시서에는 한 장만). */
+export function retirementCardStamp(evidence: CoordinatorShadowStreak): string {
+  return `coordinator-shadow-streak:${evidence.cell}:${evidence.directive}`;
+}
+
+/**
+ * 조율자 루프의 하루 틱 — 그림자 디스패치 3일 연속 판정 → 셸 디스패처 은퇴 결정 카드 1장.
+ * 카드는 기존 결정 원장(DecisionLedger.raise) 부가 형식 그대로 append 되고,
+ * 같은 3일 창에서 성립한 모든 칸+지시서 쌍을 각자 판정하고, 카드가 이미 있으면 재사용한다.
+ * (날짜가 바뀌어도 쌍마다 1장 유지).
+ */
+export async function tick(options: CoordinatorShadowTickOptions = {}): Promise<CoordinatorShadowTickResult> {
+  const root = resolveCoordinatorShadowRoot(options.root ?? process.cwd());
+  const now = options.now ?? (() => new Date());
+  const dispatches = options.dispatches ?? readDispatchJournal(coordinatorShadowJournalPath(root));
+  const today = now().toISOString().slice(0, 10);
+  const evidences = detectBuilderThreeDayStreaks(dispatches, today);
+  const evidence = evidences[0] ?? null;
+  if (!evidence) return { checked: today, evidence: null };
+
+  const ledger = new DecisionLedger({ ...(options.stateDir ? { stateDir: options.stateDir } : {}), now, repoRoot: root });
+  const outcomes = evidences.map(item => {
+    const stamp = retirementCardStamp(item);
+    const alreadyRaised = ledger.list({ status: 'all' }).some(entry =>
+      Array.isArray(entry.refs) && entry.refs.includes(stamp));
+    const entry = ledger.raiseOnce({
+      title: `셸 디스패처 은퇴 — ${item.cell} × ${item.directive} 3일 연속`,
+      category: 'other',
+      scqa: {
+        s: '조율자 그림자가 ④ 빌더로 같은 칸·같은 지시서를 달력 기준 3일 연속 디스패치했다.',
+        c: '중간층 입구 디스패처가 같은 지시를 반복 산출하는 0.2.35 최우선 병목 신호가 실측됐다.',
+        q: '셸 디스패처를 은퇴시키고 입구를 조율자 그림자로 고정할까?',
+        a: '셸 디스패처 은퇴 결정 카드를 원장에 올리고 후속 조치를 연다.',
+      },
+      options: [
+        { key: 'a', label: '은퇴 승인', consequence: '입구 디스패처를 조율자 그림자로 고정하고 셸 디스패처를 은퇴시킨다' },
+        { key: 'b', label: '관찰 연장', consequence: '은퇴를 보류하고 3일 연속 판정 관찰을 계속한다' },
+      ],
+      recommendation: { option: 'a', why: '같은 칸·같은 지시서가 달력 기준 3일 연속 — 판정 신호 충족' },
+      raisedBy: { agent: 'orchestrator-tick', track: 'OP' },
+      refs: [
+        stamp,
+        `agent:${item.agent}`,
+        ...(item.recipient ? [`recipient:${item.recipient}`] : []),
+        `cell:${item.cell}`,
+        `directive:${item.directive}`,
+        `dates:${item.dates.join(',')}`,
+      ],
+    }, stamp);
+    return { evidence: item, cardId: entry.id, alreadyRaised };
+  });
+  return { checked: today, evidence, cardId: outcomes[0]!.cardId,
+    ...(outcomes.every(outcome => outcome.alreadyRaised) ? { skipped: 'duplicate' as const } : {}) };
+}

package/src/loops/orchestrator/tick.ts

@@ -56,6 +56,8 @@ export interface TickState {
   /** ORCH-TA-HAND — cells handed to TASK-AGENT this run (card id · mode · launched). */
   handed?: Array<{ key: string; cell: string; cardId: string; mode: 'shadow' | 'live'; launched: boolean }>;
   queueOutcomes?: Array<{ queueId: string; key?: string; outcome: string }>;
+  /** COORD-ABSORB-OP-BRIDGES-FU — coordinator 수신 소비(버스 배수)의 이번 run 누적. 노드마다 배수한 replied·acknowledged 를 더해 durable 상태 파일에 남긴다. */
+  inbox?: { replied: number; acknowledged: number };
   steps: Array<{ node: Node; reason: string; count: number; targetLoopId?: string }>;
   nodes: Partial<Record<Node, 'ok' | 'skipped'>>;
   missing: string[];
@@ -133,6 +135,47 @@ function handedKeys(path: string): Set<string> {
   return keys;
 }
 
+/** COORD-ONE 조각 1 — coordinator shadow 의 TASK-AGENT 판정 소비 원장 행: `handKey`(넘김 원장 행 키, shadow: 접두 포함)가 중복 소비를 막는 식별자다. */
+type ConsumedVerdictRow = { at: string; runId: string; key: string; cell: string; cardId: string; mode: 'shadow' | 'live'; launched: boolean; handKey: string; handRunId?: string; consumed: true };
+function coordVerdictLedger(root: string): string { return join(root, 'loop', 'orchestrator', 'coord-verdicts.jsonl'); }
+/** 소비 원장이 완료로 표시한 판정들의 넘김 행 키 — 같은 판정은 두 번 소비되지 않는다. */
+function consumedVerdictHandKeys(path: string): Set<string> {
+  const keys = new Set<string>();
+  if (!existsSync(path)) return keys;
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    let row: Partial<ConsumedVerdictRow>;
+    try { row = JSON.parse(line) as typeof row; } catch { throw new Error('invalid coordinator verdict ledger'); }
+    if (row.consumed === true && typeof row.handKey === 'string') keys.add(row.handKey);
+  }
+  return keys;
+}
+/**
+ * COORD-ONE 조각 1 — tick 진입에서 coordinator shadow 가 TASK-AGENT 판정 1건(완료 넘김 행)을 소비한다.
+ * 소비는 기록 전용이다: 소비 원장에 완료 표시 한 줄을 남길 뿐 넘김 원장·자리 저널·발사 어느 live 부수효과도 내지 않고
+ * seat-loop 기본 발사 경로도 그대로 둔다(스튜어드 흡수·좌석 이관은 후속 조각). 원장을 못 읽는 진입은 소비 0건으로 끝난다.
+ */
+function consumeTaskAgentVerdict(root: string, runId: string, now: Date): void {
+  try {
+    const handLedger = handedLedger(root);
+    if (!existsSync(handLedger)) return;
+    const path = coordVerdictLedger(root);
+    const consumed = consumedVerdictHandKeys(path);
+    const verdict = [...handedRows(handLedger)].find(([handKey]) => !consumed.has(handKey));
+    if (!verdict) return;
+    const [handKey, row] = verdict;
+    const key = handKey.replace(/^shadow:/, '');
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, `${JSON.stringify({ at: now.toISOString(), runId, key, cell: row.cell, cardId: row.cardId,
+      mode: row.mode, launched: row.launched, handKey, ...(row.runId ? { handRunId: row.runId } : {}), consumed: true } as ConsumedVerdictRow)}\n`);
+    try { debug.log('loop.orchestrator', 'coord-verdict', { runId, key, mode: row.mode, launched: row.launched }); }
+    catch { /* 관측이 소비를 바꾸지 않는다 */ }
+  } catch (error) {
+    try { debug.log('loop.orchestrator', 'coord-verdict-unreadable', { error: String(error).slice(0, 200) }, { level: 'warn' }); }
+    catch { /* a failed observation cannot change the tick */ }
+  }
+}
+
 export function kstWindow(now: Date): Window {
   const hour = Number(new Intl.DateTimeFormat('en-US', { timeZone: 'Asia/Seoul', hour: '2-digit', hourCycle: 'h23' }).format(now));
   return hour < 12 ? '08' : hour < 18 ? '12' : '18';
@@ -529,11 +572,16 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
             ...(deps.coordinatorKnowhow === undefined ? {} : { knowhow: deps.coordinatorKnowhow }),
             ...(deps.coordinatorContext ? { context: deps.coordinatorContext } : {}) });
     }))();
+    // 생산 tick 경로의 실행 원문: 배수 결과를 이벤트로만 남기지 않고 run 상태에 누적해 다른 프로세스(보호자·리뷰)가 파일로 관측하게 한다.
+    state.inbox = { replied: (state.inbox?.replied ?? 0) + inbox.replied, acknowledged: (state.inbox?.acknowledged ?? 0) + inbox.acknowledged };
     if (inbox.replied || inbox.acknowledged) {
       observe('exchange', 'coordinator-inbox-replied', inbox.replied);
       observe('exchange', 'coordinator-inbox-acknowledged', inbox.acknowledged);
     }
   }
+  // COORD-ONE 조각 1 — tick 진입에서 coordinator shadow 가 TASK-AGENT 판정 1건을 소비한다: 소비 원장 기록이 전부고
+  // live 부수효과(운영 발사·자리 루프 은퇴)는 0, seat-loop 기본 발사 경로는 그대로다(흡수·이관은 후속 조각).
+  if (mode !== 'off') consumeTaskAgentVerdict(root, runId, now);
   if (mode !== 'off' && activeNode(node, window) && state.nodes[node] !== 'ok') {
     if (node === 'intake') {
       if (mode === 'live' && deps.cards) { state.cards = wishCards(deps.cards()); state.skippedCards = []; }
@@ -1014,6 +1062,13 @@ export async function degradationDeps(node: Node, deps: { config?: () => Partial
   return mode === 'live' ? { degradation: () => ({ llm: signal.llm, board: signal.board }) } : {};
 }
 
+// COORD-ENTRANCE-FOLD (0.2.42 칸 · TASK-AGENT OP 디스패처) — 조율자 루프 하루 틱 생산 진입이
+// tick() 을 호출하게 배선한다: 그림자 디스패치(날짜·대상 에이전트·칸·지시서 id)에서 ④ 빌더
+// 같은 칸·같은 지시서 달력 기준 3일 연속을 감지하면 «셸 디스패처 은퇴» 결정 카드를 기존 결정
+// 원장(DecisionLedger) 부가 형식 그대로 1장 적는다(같은 스탬프=칸+지시서 중복 방지).
+// 구현 본체: src/loops/orchestrator/coordinator-shadow.ts · 완료 경계 시험: tick.test.ts.
+import { tick as runCoordinatorShadowTick } from './coordinator-shadow.js';
+
 if (import.meta.main) {
   const node = process.argv[2];
   const index = process.argv.indexOf('--window');
@@ -1030,6 +1085,12 @@ if (import.meta.main) {
     void (async () => {
       try { await (await import('../../domains/standalone-log-sink.js')).registerStandaloneLogSink('orchestrator'); }
       catch { /* local execution can still use the per-run file */ }
+      // 관측(그림자 틱)은 본 루프를 봉쇄할 수 없다: 파손 원장 등으로 reject 하면 원인만 warn 로그로 남기고 본 노드 실행은 계속한다.
+      try { await runCoordinatorShadowTick({}); }
+      catch (error) {
+        try { debug.log('loop.orchestrator', 'coordinator-shadow-tick-failed', { node, error: String(error).slice(0, 200) }, { level: 'warn' }); }
+        catch { /* even the diagnostic sink must not block the node */ }
+      }
       await runOrchestratorNode(node as Node, { window: window as Window | undefined, ...await degradationDeps(node as Node) });
     })().catch(error => { console.error(`orchestrator ${node}: ${String(error)}`); process.exitCode = 1; });
   }

package/src/maturity/feature-maturity.ts

@@ -77,7 +77,7 @@ export const FEATURE_MATURITY = {
     'provider:rotate': 'beta', 'provider:use': 'beta', 'status-bar': 'beta',
     schedule: 'beta', guardian: 'beta', intake: 'beta', logs: 'stable', retro: 'beta', ad: 'beta', docs: 'beta',
     decisions: 'beta', directives: 'beta', claims: 'beta', lesson: 'beta', fleet: 'beta', ops: 'stable', outputs: 'beta', publish: 'beta',
-    env: 'beta', 'agent-mission': 'beta', dev: 'beta', keys: 'beta', finance: 'beta',
+    env: 'beta', 'agent-mission': 'beta', mission: 'beta', dev: 'beta', keys: 'beta', finance: 'beta',
     config: 'stable', tasks: 'stable', brief: 'beta', notify: 'beta', away: 'beta', labels: 'beta', msg: 'beta', ask: 'stable',
     onboarding: 'beta', login: 'stable', session: 'beta', chat: 'stable', repl: 'stable',
     agent: 'stable', registry: 'beta', tier: 'stable', local: 'beta', scheduler: 'beta',

package/src/mcp/mcp-oauth.ts

@@ -144,6 +144,8 @@ export interface PrepareMcpOAuthAuthorizationOpts extends McpOAuthRuntimeOpts {
   scope?: string;
   /** 저장된 등록의 포트를 못 열었을 때 새 client_id 로 다시 등록한다. */
   forceReregister?: boolean;
+  /** Discovery already verified against resourceUrl by this caller. */
+  discovered?: { resource: ProtectedResourceMetadata; metadata: AuthorizationServerMetadata };
 }
 
 /** ⛔⭐⭐ MCP 자격은 «우주를 따라가지 않는다» — 격리 매뉴얼 §6 의 전역 사용자 자산이다.
@@ -968,7 +970,7 @@ export async function getValidAccessToken(
 export async function prepareMcpOAuthAuthorization(
   opts: PrepareMcpOAuthAuthorizationOpts,
 ): Promise<McpOAuthAuthorization> {
-  const { resource, metadata } = await discoverMcpOAuth(opts.resourceMetadataUrl, opts);
+  const { resource, metadata } = opts.discovered ?? await discoverMcpOAuth(opts.resourceMetadataUrl, opts);
   const registration = await ensureClientRegistration(metadata, {
     ...opts,
     ...(opts.forceReregister ? { forceReregister: true } : {}),

package/src/model-tier/llm-tier-map.ts

@@ -222,23 +222,23 @@ const CODEX: TierMap = {
     status: 'shipping',
   },
   balanced: {
-    model: 'gpt-6-sol',
+    model: 'gpt-6.1-terra',
     reasoningLevel: 'low',
-    label: 'GPT-6 Sol · low',
-    rationale: 'Default · 빠른 코딩 (구 gpt-5.6-terra 자리 · 출력이 오히려 싸다 $10<$12)',
+    label: 'GPT-6.1 Terra · low',
+    rationale: 'Default · Codex CLI low effort · elanous 경로 기본 effort medium은 유지',
     status: 'shipping',
   },
   better: {
-    model: 'gpt-6-sol',
+    model: 'gpt-6.1-terra',
     reasoningLevel: 'medium',
-    label: 'GPT-6 Sol · medium',
-    rationale: '대표 2026-09-23 운영 기본 — 일상 코딩·구현 역할',
+    label: 'GPT-6.1 Terra · medium',
+    rationale: '일상 코딩·구현 역할 · Codex CLI 기본 effort=low에서 한 단계 높임',
     status: 'shipping',
   },
   best: {
-    model: 'gpt-6-sol',
+    model: 'gpt-6.1-sol',
     reasoningLevel: 'high',
-    label: 'GPT-6 Sol · high',
+    label: 'GPT-6.1 Sol · high',
     rationale: 'Hard reasoning · architecture (⚠️ 여기부터 과잉설계·scope creep 신고가 급증한다)',
     status: 'shipping',
   },
@@ -247,7 +247,7 @@ const CODEX: TierMap = {
   //   (2026-09-23 정정: 종전 문면 「terra 대비 4배/3.3배」는 terra 가격을 2.5/15 로 잘못 안 값이었다)
   //   기본을 올리면 사다리 맨 위 칸의 비용이 조용히 곱해진다. 더 깊게 필요하면 그때 올린다
   //   (`llm.codexReasoning.effort` = high/xhigh/max · 상한 판정은 reasoningEffortCeiling).
-  // ⛔ 아래 칸들(=일상 코딩 드라이버)은 gpt-6-sol 이다. 여기만 astra 다.
+  // Daily coding uses 6.1 Terra; this loaded tier remains GPT-6 Astra.
   loaded: {
     model: 'gpt-6-astra',
     reasoningLevel: 'medium',

package/src/model-tier/turn-tier.ts

@@ -14,7 +14,7 @@ export function explicitTurnTier(
   try {
     const resolved = resolveLlmTier(cfg.modelTier, cfg.llm.provider, { sessionId });
     if (resolved.source !== 'session-override' && resolved.source !== 'user-config-surface') return undefined;
-    // On codex the balanced·better·best tiers share one model and differ only in reasoning level (low·medium·high),
+    // Codex tiers can share a model while differing by reasoning level (low·medium·high),
     // so carrying the model alone left the slider a no-op there (10-01 live).
     const reasoningEffort = resolved.reasoningLevel ? REASONING_EFFORT[resolved.reasoningLevel] : undefined;
     return { model: resolved.model, tier: resolved.tier, source: resolved.source, ...(reasoningEffort ? { reasoningEffort } : {}) };

package/src/msg/msg-mirror-github.ts

@@ -0,0 +1,80 @@
+import { execFileSync } from 'node:child_process';
+import type { MsgMirrorTransport, MirrorTarget } from './msg-mirror-runner.js';
+
+type GhExec = (args: string[]) => string;
+type Comment = { body?: unknown };
+type Issue = { number?: unknown; title?: unknown; body?: unknown; pull_request?: unknown };
+const keyOf = (target: MirrorTarget) => `${target.repo}#${target.issueNumber}`;
+
+function defaultGhExec(args: string[]): string {
+  return execFileSync('gh', ['api', ...args], { encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 });
+}
+
+function flatPages(output: string): unknown[] {
+  const parsed: unknown = JSON.parse(output);
+  if (!Array.isArray(parsed) || !parsed.every(Array.isArray)) throw new Error('GitHub paginated response is malformed');
+  return parsed.flat();
+}
+
+function firstLine(body: string): string { return body.split(/\r?\n/, 1)[0] ?? ''; }
+
+/** GitHub issue/comment API adapter. Constructed only when the mirror command runs. */
+export class GitHubMsgMirrorTransport implements MsgMirrorTransport {
+  private readonly comments = new Map<string, { rows: Comment[]; markers: Set<string> }>();
+
+  constructor(private readonly gh: GhExec = defaultGhExec) {}
+
+  beginTick(): void { this.comments.clear(); }
+
+  private loadComments(target: MirrorTarget): { rows: Comment[]; markers: Set<string> } {
+    const key = keyOf(target);
+    const cached = this.comments.get(key);
+    if (cached) return cached;
+    const rows = flatPages(this.gh(['--paginate', '--slurp', `repos/${target.repo}/issues/${target.issueNumber}/comments?per_page=100`]))
+      .map(row => {
+        if (!row || typeof row !== 'object' || typeof (row as Comment).body !== 'string') throw new Error('GitHub comment response is malformed');
+        return row as Comment;
+      });
+    const result = { rows, markers: new Set(rows.map(row => firstLine(row.body as string))) };
+    this.comments.set(key, result);
+    return result;
+  }
+
+  countComments(target: MirrorTarget): number { return this.loadComments(target).rows.length; }
+
+  hasMarker(target: MirrorTarget, marker: string): boolean {
+    return this.loadComments(target).markers.has(marker);
+  }
+
+  postComment(target: MirrorTarget, body: string): void {
+    const comments = this.loadComments(target);
+    this.gh(['-X', 'POST', `repos/${target.repo}/issues/${target.issueNumber}/comments`, '-f', `body=${body}`]);
+    comments.rows.push({ body });
+    comments.markers.add(firstLine(body));
+  }
+
+  createNextChannel(target: MirrorTarget, idempotencyKey: string): MirrorTarget {
+    const title = `Elanous seat-message mirror · ${idempotencyKey}`;
+    const existing = flatPages(this.gh(['--paginate', '--slurp', `repos/${target.repo}/issues?state=all&per_page=100&sort=created&direction=desc`]))
+      .find((row): row is Issue => !!row && typeof row === 'object' && typeof (row as Issue).title === 'string'
+        && (row as Issue).title === title && (row as Issue).pull_request === undefined);
+    if (existing) {
+      if (!Number.isSafeInteger(existing.number) || (existing.number as number) < 1) throw new Error('existing mirror issue has invalid number');
+      return { repo: target.repo, issueNumber: existing.number as number };
+    }
+    const body = `Automated seat-message mirror channel.\n\nRotation key: ${idempotencyKey}\n`;
+    const output = this.gh(['-X', 'POST', `repos/${target.repo}/issues`, '-f', `title=${title}`, '-f', `body=${body}`]);
+    const issue: unknown = JSON.parse(output);
+    if (!issue || typeof issue !== 'object' || !Number.isSafeInteger((issue as Issue).number)
+      || ((issue as Issue).number as number) < 1) throw new Error('GitHub did not return the new mirror issue number');
+    return { repo: target.repo, issueNumber: (issue as Issue).number as number };
+  }
+
+  linkAndCloseChannel(from: MirrorTarget, to: MirrorTarget): void {
+    const marker = `<!-- elanous-msg-mirror:rotated-to:${to.repo}#${to.issueNumber} -->`;
+    if (!this.hasMarker(from, marker)) {
+      this.postComment(from, `${marker}\nMirror channel moved to [#${to.issueNumber}](https://github.com/${to.repo}/issues/${to.issueNumber}).`);
+    }
+    this.gh(['-X', 'PATCH', `repos/${from.repo}/issues/${from.issueNumber}`, '-f', 'state=closed']);
+  }
+}

package/src/msg/msg-mirror-policy.ts

@@ -0,0 +1,61 @@
+import type { Message } from './msg-store.js';
+
+/** Public GitHub mirror policy for the seat-message ledger. */
+export const MIRROR_EVENT_KINDS = ['incident', 'decision', 'correction'] as const;
+export const MIRROR_SUMMARY_INTERVAL_MS = 2 * 60 * 60 * 1000;
+export const MIRROR_ROTATE_AT = 2_300;
+
+const mirrorKinds: ReadonlySet<string> = new Set(MIRROR_EVENT_KINDS);
+
+export type MirrorEvent = Pick<Message, 'id' | 'from' | 'to' | 'body' | 'kind' | 'createdAt'>;
+
+/** Routine reports and loop traffic never become public mirror comments. */
+export function isMirrorEvent(message: Pick<Message, 'kind'>): boolean {
+  return typeof message.kind === 'string' && mirrorKinds.has(message.kind);
+}
+
+/** Returns only new eligible messages, in ledger order, without changing the input. */
+export function selectMirrorEvents(messages: readonly MirrorEvent[], afterId: number): MirrorEvent[] {
+  if (!Number.isSafeInteger(afterId) || afterId < 0) throw new Error('afterId must be a nonnegative safe integer');
+  return messages
+    .filter(message => Number.isSafeInteger(message.id) && message.id > afterId && isMirrorEvent(message))
+    .slice()
+    .sort((a, b) => a.id - b.id);
+}
+
+/** Build a deterministic, non-LLM summary for one closed two-hour interval. */
+export function buildMirrorSummary(
+  messages: readonly MirrorEvent[],
+  windowStart: string,
+  windowEnd: string,
+): string | null {
+  const start = Date.parse(windowStart);
+  const end = Date.parse(windowEnd);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) throw new Error('invalid summary window');
+  const events = messages
+    .filter(message => isMirrorEvent(message) && Number.isFinite(Date.parse(message.createdAt)))
+    .filter(message => {
+      const at = Date.parse(message.createdAt);
+      return at >= start && at < end;
+    })
+    .sort((a, b) => a.id - b.id);
+  if (events.length === 0) return null;
+
+  const counts = new Map<string, number>();
+  for (const event of events) counts.set(event.kind!, (counts.get(event.kind!) ?? 0) + 1);
+  const breakdown = MIRROR_EVENT_KINDS
+    .filter(kind => counts.has(kind))
+    .map(kind => `${kind} ${counts.get(kind)}`)
+    .join(' · ');
+  const from = new Date(start).toISOString();
+  const to = new Date(end).toISOString();
+  return `## Seat message summary (${from} – ${to})\n\n${events.length} mirrored events · ${breakdown}\n\n` +
+    events.map(event => `- #${event.id} **${event.kind}** · ${event.from} → ${event.to}: ${event.body.trim()}`).join('\n');
+}
+
+/** Rotate before GitHub's hard comment wall; callers must persist the new channel pointer. */
+export function shouldRotateMirrorChannel(commentCount: number, threshold: number = MIRROR_ROTATE_AT): boolean {
+  if (!Number.isSafeInteger(commentCount) || commentCount < 0) throw new Error('commentCount must be a nonnegative safe integer');
+  if (!Number.isSafeInteger(threshold) || threshold < 1 || threshold >= 2_500) throw new Error('threshold must be between 1 and 2499');
+  return commentCount >= threshold;
+}