elanous 0.2.38 → 0.2.41

package/src/loops/orchestrator/tick.ts

@@ -6,6 +6,7 @@ import { Database } from 'bun:sqlite';
 import { checklistDevVersion, listChecklist, type ChecklistItem } from '../../release-loop/checklist.js';
 import { readTrafficSignal } from '../../seat-loop/traffic-signal.js';
 import { runHoldHygiene, type HygieneCell, type HygieneDeps } from '../../steward/hold-hygiene.js';
+import { runDirectiveAudit, type DirectiveAuditDeps } from '../../steward/directive-audit.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS, resolveConfiguredAgentRoleLlm, type OrchestratorLoopConfig } from '../../user-config.js';
 import { rubricPriority } from '../../release-loop/rubric.js';
@@ -55,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[];
@@ -70,6 +73,7 @@ export interface TickDeps {
   heartbeatIntervalMs?: number;
   hygieneCells?: () => HygieneCell[];
   hygienePaths?: Pick<HygieneDeps, 'trafficPath' | 'metaPath' | 'dispatcherDir'>;
+  directiveAudit?: DirectiveAuditDeps;
   cards?: () => TaskCard[]; split?: SplitAdapter; placeCell?: PlaceAdapter;
   degradation?: () => { llm: boolean; board: boolean };
   gridHosts?: readonly GridHost[];
@@ -131,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';
@@ -527,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 = []; }
@@ -960,6 +1010,12 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           const sent = runHoldHygiene({ root, now, cells, ...deps.hygienePaths });
           for (const notice of sent) observe('exchange', `hold-hygiene:${notice.key}`, 1, SEAT_LOOP_IDS[notice.to]);
         } catch (error) { observe('hold-hygiene-failed', String(error).slice(0, 160), 0); }
+        // COORD-DIRECTIVE-AUDIT — 지시 원장 행마다 로직 점검(원장·로그·config)을 실제로 돌린다.
+        try {
+          const audit = runDirectiveAudit({ root, now: currentTime, ...deps.directiveAudit });
+          if (audit.alerts.length > 0) observe('directive-audit', `alerts:${audit.alerts.length}`, audit.alerts.length);
+          for (const proposal of audit.proposals) observe('directive-audit', `repair-proposal:${proposal.id}`, 1);
+        } catch (error) { observe('directive-audit-failed', String(error).slice(0, 160), 0); }
       }
       (deps.print ?? console.log)(reportLine(state));
     }

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

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

@@ -0,0 +1,219 @@
+import type { Message } from './msg-store.js';
+import { buildMirrorSummary, isMirrorEvent, MIRROR_SUMMARY_INTERVAL_MS, selectMirrorEvents, shouldRotateMirrorChannel } from './msg-mirror-policy.js';
+
+export interface MirrorTarget {
+  repo: string;
+  issueNumber: number;
+}
+
+export interface MsgMirrorState {
+  version: 1;
+  target: MirrorTarget;
+  messageCursor: number;
+  summaryWindowEnd: string;
+  rotationPending?: { from: MirrorTarget; to: MirrorTarget };
+}
+
+export interface MsgMirrorSource {
+  listAfter(afterId: number, limit: number): Message[];
+  listWindow(start: string, end: string): Message[];
+  latestId(): number;
+}
+
+export interface MsgMirrorStateStore {
+  read(): MsgMirrorState | null;
+  write(state: MsgMirrorState): void;
+}
+
+export interface MsgMirrorTransport {
+  beginTick?(): Promise<void> | void;
+  countComments(target: MirrorTarget): Promise<number> | number;
+  hasMarker(target: MirrorTarget, marker: string): Promise<boolean> | boolean;
+  postComment(target: MirrorTarget, body: string): Promise<void> | void;
+  createNextChannel(target: MirrorTarget, idempotencyKey: string): Promise<MirrorTarget> | MirrorTarget;
+  linkAndCloseChannel(from: MirrorTarget, to: MirrorTarget): Promise<void> | void;
+}
+
+export interface MsgMirrorTickOptions {
+  configuredTarget?: MirrorTarget;
+  nowMs?: number;
+  dryRun?: boolean;
+  source: MsgMirrorSource;
+  state: MsgMirrorStateStore;
+  transport: MsgMirrorTransport;
+}
+
+export interface MsgMirrorTickResult {
+  status: 'disabled' | 'dry-run' | 'synced';
+  target: MirrorTarget | null;
+  scanned: number;
+  posted: number;
+  rotated: number;
+  summaries: number;
+  sourceCursor: number;
+}
+
+const VALID_REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+
+export function validateMirrorTarget(value: unknown): MirrorTarget {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('mirror target must be an object');
+  const target = value as Record<string, unknown>;
+  if (typeof target.repo !== 'string' || !VALID_REPO.test(target.repo)
+    || typeof target.issueNumber !== 'number' || !Number.isSafeInteger(target.issueNumber) || target.issueNumber < 1) {
+    throw new Error('mirror target requires repo=owner/name and a positive issueNumber');
+  }
+  return { repo: target.repo, issueNumber: target.issueNumber as number };
+}
+
+/** Sparse settings are disabled by default; malformed nonempty settings are rejected. */
+export function configuredMirrorTarget(raw: unknown): MirrorTarget | undefined {
+  if (raw === undefined) return undefined;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('msgMirror config must be an object');
+  const target = (raw as Record<string, unknown>).target;
+  return target === undefined ? undefined : validateMirrorTarget(target);
+}
+
+export function validateMsgMirrorState(value: unknown): MsgMirrorState {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid message mirror state');
+  const state = value as Record<string, unknown>;
+  if (state.version !== 1 || typeof state.messageCursor !== 'number' || !Number.isSafeInteger(state.messageCursor) || state.messageCursor < 0
+    || typeof state.summaryWindowEnd !== 'string' || !Number.isFinite(Date.parse(state.summaryWindowEnd))) throw new Error('invalid message mirror state');
+  const target = validateMirrorTarget(state.target);
+  const pending = state.rotationPending;
+  const rotationPending = pending && typeof pending === 'object' && !Array.isArray(pending)
+    ? { from: validateMirrorTarget((pending as Record<string, unknown>).from), to: validateMirrorTarget((pending as Record<string, unknown>).to) }
+    : undefined;
+  if (pending !== undefined && !rotationPending) throw new Error('invalid pending mirror rotation');
+  return { version: 1, target, messageCursor: state.messageCursor as number, summaryWindowEnd: new Date(state.summaryWindowEnd as string).toISOString(),
+    ...(rotationPending ? { rotationPending } : {}) };
+}
+
+function initialState(target: MirrorTarget, nowMs: number, latestMessageId: number): MsgMirrorState {
+  if (!Number.isSafeInteger(latestMessageId) || latestMessageId < 0) throw new Error('source latest message ID is invalid');
+  const end = Math.floor(nowMs / MIRROR_SUMMARY_INTERVAL_MS) * MIRROR_SUMMARY_INTERVAL_MS;
+  return { version: 1, target, messageCursor: latestMessageId, summaryWindowEnd: new Date(end).toISOString() };
+}
+
+function eventMarker(id: number): string { return `<!-- elanous-msg-mirror:event:${id} -->`; }
+function summaryMarker(start: string): string { return `<!-- elanous-msg-mirror:summary:${start} -->`; }
+
+function renderEvent(message: Message): string {
+  return `## ${message.kind} · #${message.id}\n\n**${message.from} → ${message.to}** · ${message.createdAt}\n\n${message.body.trim()}`;
+}
+
+async function prepareTarget(state: MsgMirrorState, transport: MsgMirrorTransport, dryRun: boolean): Promise<{
+  state: MsgMirrorState; rotated: number;
+}> {
+  let current = state;
+  let rotated = 0;
+  if (current.rotationPending) {
+    if (dryRun) return { state: current, rotated };
+    await transport.linkAndCloseChannel(current.rotationPending.from, current.rotationPending.to);
+    current = { ...current, rotationPending: undefined };
+  }
+  const count = await transport.countComments(current.target);
+  if (!shouldRotateMirrorChannel(count)) return { state: current, rotated };
+  if (dryRun) return { state: current, rotated };
+  const oldTarget = current.target;
+  const nextTarget = validateMirrorTarget(await transport.createNextChannel(oldTarget,
+    `msg-mirror-rotate:${oldTarget.repo}#${oldTarget.issueNumber}`));
+  current = { ...current, target: nextTarget, rotationPending: { from: oldTarget, to: nextTarget } };
+  // Persist the pointer before closing the old issue. On restart the pending link/close is retried.
+  // If this write fails, the adapter's idempotency key prevents creating another channel.
+  return { state: current, rotated: 1 };
+}
+
+/** One idempotent mirror pass. All GitHub effects are behind the injected transport. */
+export async function runMsgMirrorTick(options: MsgMirrorTickOptions): Promise<MsgMirrorTickResult> {
+  const nowMs = options.nowMs ?? Date.now();
+  if (!Number.isFinite(nowMs)) throw new Error('nowMs must be finite');
+  const stored = options.state.read();
+  const configured = options.configuredTarget ? validateMirrorTarget(options.configuredTarget) : undefined;
+  if (!stored && !configured) return { status: 'disabled', target: null, scanned: 0, posted: 0, rotated: 0, summaries: 0, sourceCursor: 0 };
+  await options.transport.beginTick?.();
+  let state = stored ? validateMsgMirrorState(stored) : initialState(configured!, nowMs, options.source.latestId());
+  let scanned = 0, posted = 0, rotated = 0, summaries = 0;
+  if (!options.dryRun) options.state.write(state);
+
+  const startTarget = state.target;
+  const prepared = await prepareTarget(state, options.transport, options.dryRun === true);
+  state = prepared.state;
+  rotated += prepared.rotated;
+  if (!options.dryRun && state !== stored) options.state.write(state);
+
+  // A rotation is recorded before side effects that close the previous issue.
+  if (state.rotationPending && !options.dryRun) {
+    await options.transport.linkAndCloseChannel(state.rotationPending.from, state.rotationPending.to);
+    state = { ...state, rotationPending: undefined };
+    options.state.write(state);
+  }
+
+  let page = options.source.listAfter(state.messageCursor, 1000);
+  while (page.length > 0) {
+    const eligible = new Map(selectMirrorEvents(page, state.messageCursor).map(message => [message.id, message]));
+    for (const message of page) {
+      scanned++;
+      const event = eligible.get(message.id);
+      if (event) {
+        const preparedNext = await prepareTarget(state, options.transport, options.dryRun === true);
+        if (preparedNext.rotated) {
+          state = preparedNext.state;
+          rotated += preparedNext.rotated;
+          if (!options.dryRun) {
+            options.state.write(state);
+            if (state.rotationPending) {
+              await options.transport.linkAndCloseChannel(state.rotationPending.from, state.rotationPending.to);
+              state = { ...state, rotationPending: undefined };
+              options.state.write(state);
+            }
+          }
+        }
+        const marker = eventMarker(event.id);
+        if (!options.dryRun && !(await options.transport.hasMarker(state.target, marker))) {
+          await options.transport.postComment(state.target, `${marker}\n${renderEvent(event)}`);
+          posted++;
+        }
+      }
+      state = { ...state, messageCursor: message.id };
+      if (!options.dryRun) options.state.write(state);
+    }
+    if (page.length < 1000) break;
+    page = options.source.listAfter(state.messageCursor, 1000);
+  }
+
+  let windowStart = Date.parse(state.summaryWindowEnd);
+  const nowWindowEnd = Math.floor(nowMs / MIRROR_SUMMARY_INTERVAL_MS) * MIRROR_SUMMARY_INTERVAL_MS;
+  while (windowStart + MIRROR_SUMMARY_INTERVAL_MS <= nowWindowEnd) {
+    const windowEnd = windowStart + MIRROR_SUMMARY_INTERVAL_MS;
+    const from = new Date(windowStart).toISOString();
+    const to = new Date(windowEnd).toISOString();
+    const summary = buildMirrorSummary(options.source.listWindow(from, to), from, to);
+    if (summary) {
+      const preparedNext = await prepareTarget(state, options.transport, options.dryRun === true);
+      if (preparedNext.rotated) {
+        state = preparedNext.state;
+        rotated += preparedNext.rotated;
+        if (!options.dryRun) {
+          options.state.write(state);
+          if (state.rotationPending) {
+            await options.transport.linkAndCloseChannel(state.rotationPending.from, state.rotationPending.to);
+            state = { ...state, rotationPending: undefined };
+            options.state.write(state);
+          }
+        }
+      }
+      const marker = summaryMarker(from);
+      if (!options.dryRun && !(await options.transport.hasMarker(state.target, marker))) {
+        await options.transport.postComment(state.target, `${marker}\n${summary}`);
+        posted++;
+      }
+      summaries++;
+    }
+    state = { ...state, summaryWindowEnd: to };
+    if (!options.dryRun) options.state.write(state);
+    windowStart = windowEnd;
+  }
+
+  return { status: options.dryRun ? 'dry-run' : 'synced', target: options.dryRun ? startTarget : state.target,
+    scanned, posted, rotated, summaries, sourceCursor: state.messageCursor };
+}

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

@@ -0,0 +1,33 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { validateMsgMirrorState, type MsgMirrorState, type MsgMirrorStateStore } from './msg-mirror-runner.js';
+
+export function defaultMsgMirrorStatePath(): string {
+  return join(elanousStateRoot(), 'msg', 'github-mirror-state.json');
+}
+
+/** One durable rotation pointer and progress cursor, stored atomically in the active state universe. */
+export class JsonMsgMirrorStateStore implements MsgMirrorStateStore {
+  constructor(readonly path: string = defaultMsgMirrorStatePath()) {}
+
+  read(): MsgMirrorState | null {
+    if (!existsSync(this.path)) return null;
+    const parsed: unknown = JSON.parse(readFileSync(this.path, 'utf8'));
+    return validateMsgMirrorState(parsed);
+  }
+
+  write(state: MsgMirrorState): void {
+    const normalized = validateMsgMirrorState(state);
+    mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+    const temp = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temp, `${JSON.stringify(normalized, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+      renameSync(temp, this.path);
+    } catch (error) {
+      try { rmSync(temp, { force: true }); } catch { /* preserve the original write error */ }
+      throw error;
+    }
+  }
+}

package/src/msg/msg-store.ts

@@ -129,6 +129,7 @@ export class MsgStore {
       created_at TEXT NOT NULL
     );
     CREATE INDEX IF NOT EXISTS idx_msg_messages_recipient_id ON msg_messages(recipient, id);
+    CREATE INDEX IF NOT EXISTS idx_msg_messages_created_at_id ON msg_messages(created_at, id);
     CREATE TABLE IF NOT EXISTS msg_cursors (
       recipient TEXT PRIMARY KEY,
       last_id INTEGER NOT NULL DEFAULT 0 CHECK(last_id >= 0)
@@ -307,6 +308,16 @@ export class MsgStore {
       WHERE id > ? ORDER BY id ASC LIMIT ?`).all(after, limit) as MessageRow[]).map(fromRow));
   }
 
+  /** Read a half-open UTC timestamp window for periodic message-mirror summaries. */
+  listCreatedBetween(start: string, end: string): Message[] {
+    const startMs = Date.parse(start);
+    const endMs = Date.parse(end);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) throw new Error('invalid message time window');
+    return this.readWithSchema(hasReplyTo => (this.db.query(`SELECT id, sender, recipient, body, kind,
+      ${hasReplyTo ? 'reply_to' : 'NULL AS reply_to'}, created_at FROM msg_messages
+      WHERE created_at >= ? AND created_at < ? ORDER BY id ASC`).all(new Date(startMs).toISOString(), new Date(endMs).toISOString()) as MessageRow[]).map(fromRow));
+  }
+
   latestId(): number {
     return (this.db.query('SELECT COALESCE(MAX(id), 0) AS id FROM msg_messages').get() as { id: number }).id;
   }

package/src/nexus/api/harness-api.ts

@@ -9,6 +9,7 @@ import { queryRunScreenKey } from '../../self-implement/run-ledger.js';
 import { logsDbPath } from '../../mss/logging/log-store.js';
 import { redactSecretText } from '../../debug/log.js';
 import { runAskLaunchFlow, type AskLaunchFlowResult } from '../../self-dev/ask-launch-flow.js';
+import { defaultGoalAuthorSelfResolve } from '../../self-implement/goal-author-clarification.js';
 import * as askIo from '../../self-dev/ask-launch-io.js';
 import { DAEMON_HARNESS_ASK_ENTRANCE } from '../../self-dev/entrance-registry.js';
 import { prepareAskLaunch } from '../../self-dev/launch-preflight.js';
@@ -211,12 +212,12 @@ function defaultAskDeps(rows: Awaited<ReturnType<typeof askIo.readAskPreflightLo
     print: () => {},
     log: (event: string, data: Record<string, unknown>, level?: 'info' | 'warn' | 'error') => debug.log('harness-http', event, data, { level }),
     readLine: async () => '',
-    readClarification: async () => '',
     readFile: (file: string) => readFileSync(file, 'utf8'),
     writeFile: (file: string, data: string) => writeFileSync(file, data, 'utf8'),
     cwd: () => process.cwd(),
     now: () => Date.now(),
     isInteractive: () => false,
+    selfResolveClarification: defaultGoalAuthorSelfResolve,
     buildPreflightDeps: askIo.buildAskPreflightDeps,
     priorBlockSamples: () => askIo.priorBlockSamplesFrom(rows),
     recentAuthoringSamples: () => askIo.recentAuthoringSamplesFrom(rows),