elanous 0.2.40 → 0.2.41

package/src/intelligence-map/model-catalog.ts

@@ -13,6 +13,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from '
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import type { ModelCatalog, ModelEntry } from './types.js';
+import { resolveModelAlias } from './model-alias.js';
 
 // 2026-05-03 snapshot — added Kimi (Moonshot) / Qwen 3.6 (Alibaba) /
 // GLM 5.x (Zhipu) families. Open-weight vs cloud-only is captured by
@@ -172,16 +173,55 @@ export const BUILTIN_CATALOG: ModelCatalog = {
       inputPerMtok: 2,
       outputPerMtok: 10,
       local: false,
-      tags: ['coding', 'reasoning', 'agentic', 'balanced', 'long-context'],
+      tags: ['coding', 'reasoning', 'agentic', 'balanced', 'legacy', 'long-context'],
       bestFor: ['daily-coding', 'multi-file-edit', 'autonomous-implementation', 'complex-architecture'],
       reservedOutputTokens: 12_000,
+      // Coarse capability tier (legacy state is recorded in tags; this schema has no `legacy` tier).
       tier: 'better',
       variantOf: 'gpt-6',
       effortAxis: 'sol',
       reasoningEffortCeiling: 'max',
       releasedAt: '2026-09-22',
       classification: { source: 'builtin', at: '2026-09-23' },
-      notes: '대표 2026-09-23 운영 기본(medium) — 구 gpt-5.6-terra 대체. 구독·API 둘 다 확인. effort none/low/medium(기본)/high/xhigh/max · 1.05M ctx(입력 922K · 출력 128K) · 컷오프 2026-04-20. ⚠️ 272K 초과 프롬프트는 input·cache 2배 · output 1.5배로 «요청 전체»가 재과금된다.',
+      notes: 'Legacy GPT-6 Sol retained for explicit compatibility; GPT-6.1 Terra is the current Codex default. 1.05M context. Per OP 2026-10-28 price direction, its cached-input estimate matches GPT-6.1 Sol ($0.10/M).',
+    },
+    {
+      id: 'gpt-6.1-terra',
+      provider: 'openai-codex',
+      family: 'gpt-6',
+      contextWindow: 500_000,
+      inputPerMtok: 1,
+      outputPerMtok: 5,
+      local: false,
+      tags: ['coding', 'reasoning', 'agentic', 'balanced'],
+      bestFor: ['daily-coding', 'multi-file-edit', 'autonomous-implementation'],
+      reservedOutputTokens: 12_000,
+      tier: 'better',
+      variantOf: 'gpt-6',
+      effortAxis: 'terra',
+      reasoningEffortCeiling: 'max',
+      releasedAt: '2026-10-26',
+      classification: { source: 'builtin', at: '2026-10-28' },
+      notes: 'GPT-6.1 Terra · Codex CLI 0.164.0 카탈로그 실측 · 500K context · $1/$5, cached input $0.05/M. CLI 기본 effort=low; elanous 경로 기본 medium 유지.',
+    },
+    {
+      id: 'gpt-6.1-sol',
+      provider: 'openai-codex',
+      family: 'gpt-6',
+      contextWindow: 500_000,
+      inputPerMtok: 2,
+      outputPerMtok: 10,
+      local: false,
+      tags: ['coding', 'reasoning', 'agentic', 'frontier'],
+      bestFor: ['complex-architecture', 'long-horizon-agentic', 'deep-analysis'],
+      reservedOutputTokens: 16_000,
+      tier: 'best',
+      variantOf: 'gpt-6',
+      effortAxis: 'sol',
+      reasoningEffortCeiling: 'max',
+      releasedAt: '2026-10-26',
+      classification: { source: 'builtin', at: '2026-10-28' },
+      notes: 'GPT-6.1 Sol · Codex CLI 0.164.0 카탈로그 실측 · 500K context · $2/$10, cached input $0.10/M. CLI 기본 effort=low; elanous 경로 기본 medium 유지.',
     },
     {
       id: 'gpt-6-luna',
@@ -944,6 +984,23 @@ export function reasoningEffortCeiling(modelId: string | undefined): ReasoningEf
   return 'medium';                               // local 등 미상 — 보수적
 }
 
+export const CHILD_LLM_EFFORT_LADDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+
+/** Shared explicit effort check for task hand and the dev entrypoint. */
+export function childLlmEffortProblem(model: string, entered: string): string | undefined {
+  const effort = entered.trim().toLowerCase();
+  const ladder: readonly string[] = CHILD_LLM_EFFORT_LADDER;
+  if (!ladder.includes(effort)) {
+    return `--child-llm-effort 알 수 없음: ${entered} · 후보: ${CHILD_LLM_EFFORT_LADDER.join(', ')}`;
+  }
+  const ceiling = reasoningEffortCeiling(resolveModelAlias(model.trim()) ?? model.trim());
+  if (ceiling === 'none') return `--child-llm-effort 거부: ${model} 은 추론 노력을 «안 받는다»(ceiling=none)`;
+  if (ladder.indexOf(effort) > ladder.indexOf(ceiling)) {
+    return `--child-llm-effort 거부: ${effort} 가 ${model} 의 상한(${ceiling})을 넘는다`;
+  }
+  return undefined;
+}
+
 // ── Paths ──────────────────────────────────────────────────────────────
 
 export function getCatalogPath(home: string = homedir()): string {

package/src/llm/model-defaults.ts

@@ -49,12 +49,12 @@ export function setAutoProviderDecisionForTest(fn: (() => LLMProviderName | unde
 /** config/tier 해석이 «실패»했을 때만 타는 최후 폴백. 티어 사다리가 안 읽히는
  *  상황(부팅 초기·손상된 config)에서도 지점이 «성능 등급에 맞는» 모델을 얻게 한다. */
 const LEGACY_TIER_FALLBACK: Readonly<Record<ModelTier, string>> = {
-  // 🩸 2026-09-23 — 이 폴백이 GPT-6 이관 뒤에도 gpt-5.6-* 였다(결정 지적 · GPT-6 에는 terra 가 없다).
+  // Keep the fallback aligned with the GPT-6.1 Codex ladder if config/tier lookup fails.
   //   사다리가 안 읽힐 때만 쓰이므로 codex 사다리의 «현재 값»과 같게 둔다(시험이 사다리와 대조한다).
   budget: 'gpt-6-luna',
-  balanced: 'gpt-6-sol',
-  better: 'gpt-6-sol',
-  best: 'gpt-6-sol',
+  balanced: 'gpt-6.1-terra',
+  better: 'gpt-6.1-terra',
+  best: 'gpt-6.1-sol',
   loaded: 'gpt-6-astra',
 };
 

package/src/llm.ts

@@ -3,6 +3,7 @@
 // Auto-routes based on model name prefix, or picks the first available provider.
 
 import { wellFormedLLMMessages } from './llm-wellformed.js';
+import { truncateOutput } from './output-truncation.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { testFakeLlmEnabled, testFakeLlmProvider } from './ux-sim/fake-llm.js';
 import { realpathSync } from 'node:fs';
@@ -455,6 +456,9 @@ export interface LLMOpts {
       previousChars?: number;
     }) => void;
   };
+  /** Optional cap for text tool results accumulated into the conversation history.
+   *  Oversized results are spilled to a local file and represented by head/tail. */
+  toolResultInlineLimitBytes?: number;
   /** Optional model role attached to this request's usage observation. */
   usageRole?: ModelRole;
   /** Optional per-call metering phase; absent calls keep the existing ledger shape. */
@@ -7506,13 +7510,33 @@ function resultText(result: unknown): string {
 }
 
 /** skill_exec returns structured host metadata, but its model-facing tool result is the answer body. */
-function toolResultContentForCall(toolName: string, result: unknown): string {
+function toolResultContentForCall(toolName: string, result: unknown, inlineLimitBytes?: number): string {
+  let content: string;
   if (toolName === 'skill_exec' && result && typeof result === 'object'
     && typeof (result as { output?: unknown }).output === 'string') {
-    if ((result as { ok?: unknown }).ok === false) return JSON.stringify(result);
-    return (result as { output: string }).output;
+    content = (result as { ok?: unknown }).ok === false
+      ? JSON.stringify(result)
+      : (result as { output: string }).output;
+  } else {
+    content = typeof result === 'string' ? result : JSON.stringify(result);
+  }
+  if (!Number.isFinite(inlineLimitBytes) || inlineLimitBytes === undefined || inlineLimitBytes <= 0) return content;
+  const safeToolName = toolName.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 48) || 'tool';
+  const capped = truncateOutput(content, {
+    toolName: `tool-result-${safeToolName}`,
+    inlineLimit: inlineLimitBytes,
+    headBytes: Math.floor(inlineLimitBytes * 0.6),
+    tailBytes: Math.floor(inlineLimitBytes * 0.2),
+  });
+  if (capped.spilled) {
+    debug.log('llm.router', 'tool-result.output-spilled', {
+      tool: safeToolName,
+      originalBytes: capped.originalBytes,
+      inlineLimitBytes,
+      savedPath: capped.savedPath,
+    });
   }
-  return typeof result === 'string' ? result : JSON.stringify(result);
+  return capped.output;
 }
 
 function detectExecutionFailure(result: unknown): boolean {
@@ -8921,7 +8945,7 @@ export async function streamLLMWithTools(
       turn, historyLen: history.length,
     }, { level: 'info' });
 
-    // Mid-loop context backstop — with the codex/unlimited tool-loop cap
+    // Turn context backstop — with the codex/unlimited tool-loop cap
     // removed, a long tool-heavy turn (esp. mission build) grows `history`
     // unbounded until it overflows the model context window and the provider
     // throws. ref codex / opencode bound exploration by COMPACTION, not a
@@ -9371,6 +9395,8 @@ export async function streamLLMWithTools(
           ...(ev.revisedPrompt !== undefined ? { revisedPrompt: ev.revisedPrompt } : {}),
         });
       } else if (ev.type === 'usage') {
+        // Provider parsers normalize inputTokens to uncached input; cache
+        // reads/writes are separate fields (prompt-cache/types.ts contract).
         // ⭐ 주 에이전트 턴의 토큰·비용을 «게이트 없이» 남긴다(2026-09-24 실측: 이 줄이 없어 3시간 `llm.usage`
         //   18행이 전부 곁가지 두 자리였고, 하니스 런 비용의 거의 전부가 관측 밖이었다). 곁가지와 같은 모양 ·
         //   모르는 모델은 금액 대신 `cost.kind='unknown'`. runId 는 debug.log 가 붙인다. 실패해도 턴은 계속.
@@ -11358,6 +11384,11 @@ export async function streamLLMWithTools(
         }
         const dispatchIndex = callsToDispatch.findIndex((candidate) => candidate.id === call.id);
         const { result, isError } = dispatchedResults[dispatchIndex]!;
+        const toolResultInlineLimitBytes = opts.toolResultInlineLimitBytes === undefined
+          ? undefined
+          : activeProvider.name === 'openai-codex'
+            ? Math.min(opts.toolResultInlineLimitBytes, 10 * 1024)
+            : opts.toolResultInlineLimitBytes;
         const imageBearing = maybeImageBearingResult(result);
         if (imageBearing) {
           // Image-bearing tool result (Phase 1, 2026-05-05) — see
@@ -11370,7 +11401,7 @@ export async function streamLLMWithTools(
             tool_use_id: call.id,
             content: [
               { type: 'image', mediaType: imageBearing.mediaType, base64: imageBearing.dataB64 },
-              { type: 'text', text: JSON.stringify(imageBearing.rest) },
+              { type: 'text', text: toolResultContentForCall(call.name, JSON.stringify(imageBearing.rest), toolResultInlineLimitBytes) },
             ],
             ...(isError ? { isError: true } : {}),
           });
@@ -11378,7 +11409,7 @@ export async function streamLLMWithTools(
           resultBlocks.push({
             type: 'tool_result',
             tool_use_id: call.id,
-            content: toolResultContentForCall(call.name, result),
+            content: toolResultContentForCall(call.name, result, toolResultInlineLimitBytes),
             ...(isError ? { isError: true } : {}),
           });
         }
@@ -11764,11 +11795,11 @@ import {
 } from './oauth/codex.js';
 import { extractChatGPTClaims } from './oauth/jwt.js';
 
-// ⭐ 2026-09-23 (대표) — 운영 기본을 GPT-6 Sol 로 옮겼다(구 gpt-5.6-terra).
+// ⭐ 2026-10-28 — current Codex default is GPT-6.1 Terra.
 //   ⛔ 이 상수는 «최후 폴백»이다 — 정상 경로는 `llm-tier-map` 의 사다리를 탄다.
-//   📏 구독 경로 실호출 확인(codex-cli 0.155.1 · 2026-09-23): `codex exec --model gpt-6-sol` ✅
-//   ⚠️ 0.154.0 에서는 같은 계정이 400 이었다 — 클라이언트 판이 게이트였다.
-export const CODEX_DEFAULT_MODEL = 'gpt-6-sol';
+//   Codex CLI 0.164.0: `codex exec -m gpt-6.1-terra` returned successfully on 2026-10-28.
+//   Elanous ACP Codex app-server also returned on this model; Elanous's better-tier effort remains medium.
+export const CODEX_DEFAULT_MODEL = 'gpt-6.1-terra';
 export const CODEX_DEFAULT_URL = 'https://api.openai.com/v1/chat/completions';
 
 /** Build an OpenAI-compatible provider (grok / openai) using the

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 = []; }

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;
+}