elanous 0.2.38 → 0.2.41

package/src/chat/index.ts

@@ -452,12 +452,21 @@ export interface SlashCommand {
   name: string;        // e.g. 'quit'
   aliases?: string[];  // e.g. ['q', 'exit']
   description: string; // shown in picker
+  /** Keep a command executable, but omit it from slash discovery surfaces. */
+  hidden?: boolean;
   /** First-positional-arg suggestions (static). E.g. /plugin → [list, activate, ...]. */
   subcommands?: string[];
 }
 
+/** The 15 slash commands exposed on the first-use menu and in /help. */
+export const SLASH_MENU_POLICY = {
+  required: ['help', 'status', 'model', 'clear', 'resume', 'quit', 'now', 'harness', 'memory', 'side'],
+  reserve: ['context', 'remaining', 'session', 'setup', 'decide'],
+} as const;
+const FIRST_USE_SLASH_COMMANDS: ReadonlySet<string> = new Set([...SLASH_MENU_POLICY.required, ...SLASH_MENU_POLICY.reserve]);
+
 // Default commands available in the input
-export const SLASH_COMMANDS: SlashCommand[] = [
+export const SLASH_COMMANDS: SlashCommand[] = ([
   { name: 'help',  aliases: ['?'],         description: '명령과 키 보기' },
   { name: 'resume',    aliases: [],             description: '지난 대화 이어 가기 · /resume <id 앞자리>' },
   { name: 'model',     aliases: ['m'],           description: '모델 바꾸기 — /model 빠름|보통|깊음 (코드명도 됨)', subcommands: ['빠름', '보통', '깊음', 'codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
@@ -538,11 +547,12 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'voice-chat', aliases: ['vc'], description: 'Continuous voice chat mode — speak, elanous replies in voice (Phase 4-5). Subcommands: start / stop / cancel / status. Chord: Alt+R toggles enter/exit anywhere.', subcommands: ['start', 'stop', 'cancel', 'status'] },
   { name: 'auto-tts', aliases: ['tts', 'autotts'], description: 'Auto-TTS for chat responses (Phase 2) — speaks LLM replies sentence-by-sentence. Subcommands: on / off / toggle / status.', subcommands: ['on', 'off', 'toggle', 'status'] },
   { name: 'directive', aliases: [], description: '(운영) 지시를 Linear 이슈로 기록' },
-];
+]).map((command) => ({ ...command, hidden: !FIRST_USE_SLASH_COMMANDS.has(command.name) }));
 
 /** Every user-visible slash spelling, normalized for runtime-catalog comparison. */
 export function displayedSlashCommandNames(commands: readonly SlashCommand[] = SLASH_COMMANDS): string[] {
-  return commands.flatMap((command) => [command.name, ...(command.aliases ?? [])]);
+  return commands.filter((command) => !command.hidden)
+    .flatMap((command) => [command.name, ...(command.aliases ?? [])]);
 }
 
 /** Score and rank slash commands against the user's typed text (sans leading `/`).
@@ -553,15 +563,16 @@ export function displayedSlashCommandNames(commands: readonly SlashCommand[] = S
  *    prefix-on-alias         80
  *    substring-on-name       50
  *    word-start in desc      10  (regex \b<text>)
- *  Sort by score desc, then name asc. Empty text returns the input list
- *  unchanged. */
+ *  Sort by score desc, then name asc. Hidden commands are omitted from discovery,
+ *  while the dispatch registry continues to accept direct input. */
 export function filterSlashCommands(text: string, commands: SlashCommand[]): SlashCommand[] {
+  const discoverable = commands.filter((command) => !command.hidden);
   const q = text.toLowerCase();
-  if (!q) return commands;
+  if (!q) return discoverable;
   const escaped = q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const descRe = new RegExp(`\\b${escaped}`, 'i');
   const scored: { cmd: SlashCommand; score: number }[] = [];
-  for (const cmd of commands) {
+  for (const cmd of discoverable) {
     const name = cmd.name.toLowerCase();
     const aliases = (cmd.aliases ?? []).map(a => a.toLowerCase());
     let score = 0;
@@ -801,6 +812,11 @@ export async function textInput(opts: {
   onKey?: (key: import('../tui.js').Key) =>
     | 'consumed' | 'passthrough'
     | Promise<'consumed' | 'passthrough'>;
+  /** Host escape-chord override. Runs before textInput's unconditional
+   *  quit path so a host can turn a chord into an in-app action. */
+  onQuitChord?: (key: import('../tui.js').Key) =>
+    | 'consumed' | 'passthrough'
+    | Promise<'consumed' | 'passthrough'>;
   /** Provide candidate file/directory entries for the `@`-mention
    *  picker. Called with whatever the user has typed after `@` (may
    *  include subpath fragments like `foo/ba`). Host decides what
@@ -1596,6 +1612,16 @@ export async function textInput(opts: {
       });
     }
 
+    // A host may claim a quit chord as an in-app action (classic
+    // dashboard Ctrl+\\ shows side-tab guidance and keeps the TUI alive).
+    if (isTextInputQuitChord(key) && opts.onQuitChord) {
+      const quitRoute = await Promise.resolve(opts.onQuitChord(key));
+      if (quitRoute === 'consumed') {
+        drawAll();
+        continue;
+      }
+    }
+
     // Hard exit must win over modal/VW pre-routing. When a foreground
     // virtual window is open, onPreKey may hand keys to the modal
     // surface before textInput's own quit branch runs. Claim the quit

package/src/chat/pickers/state.ts

@@ -237,7 +237,13 @@ export function createPickerState(deps: PickerDeps): PickerState {
 
   const filteredSlash = (buf: PickerBufferView): SlashCommand[] => {
     const { role, showBeta } = readTuiSlashAudience();
-    return filterSlashCommands((buf.lines[0] ?? '').slice(1), deps.commands)
+    // /directive is intentionally outside the compact first-use menu, but an owner must be able
+    // to discover its ops-only command in the live palette. Keep that role-specific exception local
+    // to the palette so the shared first-use menu and help catalog remain at their 15-command policy.
+    const paletteCommands = role === 'owner'
+      ? deps.commands.map((command) => command.name === 'directive' ? { ...command, hidden: false } : command)
+      : deps.commands;
+    return filterSlashCommands((buf.lines[0] ?? '').slice(1), paletteCommands)
       .filter((cmd) => (role === 'owner' && slashMaturity(cmd.name) === undefined) || slashVisibleFor(cmd.name, role, { showBeta }));
   };
 

package/src/cli/agent-cli.ts

@@ -68,6 +68,25 @@ export function setCliAgentDispatchForTesting(dispatch: CliAgentDispatch | undef
   cliAgentDispatchForTesting = dispatch;
 }
 
+/** A completed standalone agent turn must not wait forever for a tool's leftover handle. */
+function armAgentCliExitSafetyNet(): void {
+  const timer = setTimeout(() => {
+    try {
+      const runtime = process as typeof process & {
+        _getActiveHandles?: () => Array<{ constructor?: { name?: string } }>;
+        _getActiveRequests?: () => Array<{ constructor?: { name?: string } }>;
+      };
+      const handleTypes = runtime._getActiveHandles?.().map(h => h.constructor?.name ?? 'unknown') ?? [];
+      const requestTypes = runtime._getActiveRequests?.().map(r => r.constructor?.name ?? 'unknown') ?? [];
+      debug.log('agent.cli.exit', 'grace-expired', { handleTypes, requestTypes }, { level: 'warn' });
+      debug.flush();
+    } finally {
+      process.exit(0);
+    }
+  }, 1_000);
+  timer.unref();
+}
+
 export function registerAgentCommands(program: Command): void {
   const agentCommand = program
   .command('agent')
@@ -128,6 +147,10 @@ export function registerAgentCommands(program: Command): void {
       // commander stores --no-tools as `tools: false`, plain absence as undefined → default true here.
       enableTools: opts.tools !== false,
     });
+    // runChatTurnCli has already flushed its JSON reply. Let clean turns exit
+    // naturally; a referenced child/socket/timer left by a tool gets one second
+    // before we log the surviving handles and end this standalone process.
+    armAgentCliExitSafetyNet();
   });
 
 // ── agent dispatch — RFC #7333 `A1` (트리거) ──
@@ -413,7 +436,7 @@ tierCmd
  *  ui.info trailer and instead emits exactly ONE JSON line on stdout
  *  at end-of-turn:
  *    {sessionId, provider, model, reply, finalReply, transcript, logPath,
- *     budget, durationMs, ts}
+ *     budget, durationMs, ts, incomplete}
  *  Stable shape so LLMs can self-spawn `elanous chat` for follow-ups
  *  without parsing human-readable terminal output. */
 export async function runChatTurnCli(opts: {
@@ -484,7 +507,7 @@ export async function runChatTurnCli(opts: {
     dbg.setAmbientSessionId?.(session.id);
   } catch { /* debug module unavailable — fine */ }
   const replyChunks: string[] = [];
-  // Tool calls delimit assistant messages. finalReply retains its last non-empty-message meaning.
+  // Tool calls delimit assistant messages. Only text after the last tool call can be the final reply.
   let segmentChunks: string[] = [];
   let lastSegment = '';
   let finalMessage = '';
@@ -507,14 +530,17 @@ export async function runChatTurnCli(opts: {
   let tools: ReturnType<typeof buildCliAgentTools> | undefined;
   let dispatchTool: ((name: string, args: Record<string, unknown>) => Promise<unknown>) | undefined;
   let enabledToolNames: string[] | undefined;
+  const toolAbort = new AbortController();
+  const abortToolsOnSigint = (): void => toolAbort.abort();
   if (opts.enableTools) {
     const built = buildCliAgentTools(opts.cfg, harnessSpace ? {
       sessionId: session.id,
       emitFeedback: emitHarnessFeedbackProgress,
     } : undefined);   // ★ cfg 전달 → financeEnabled 시 finance 팩 노출(서피스 게이팅 정리)
     tools = built;
-    dispatchTool = built.dispatch;
+    dispatchTool = (name, args) => built.dispatch(name, args, { signal: toolAbort.signal });
     enabledToolNames = built.specs.map(s => s.name);
+    process.once('SIGINT', abortToolsOnSigint);
   }
   // Wire the universal preamble (project anchor + project tree +
   // family addendum + session-specific guidance) into every CLI system
@@ -604,6 +630,8 @@ export async function runChatTurnCli(opts: {
       process.exit(2);
     }
     throw err;
+  } finally {
+    if (opts.enableTools) process.removeListener('SIGINT', abortToolsOnSigint);
   }
   if (!sawToolCall && replyChunks.length === 0 && result.text) {
     replyChunks.push(result.text);
@@ -611,6 +639,7 @@ export async function runChatTurnCli(opts: {
     if (!opts.json && !opts.enableTools) process.stdout.write(result.text);
   }
   closeSegment();
+  const incomplete = sawToolCall && finalMessage.length === 0;
   if (opts.json) {
     let logPath: string | null = null;
     try {
@@ -624,17 +653,23 @@ export async function runChatTurnCli(opts: {
       model: result.model ?? null,
       reply: finalMessage,
       transcript: replyChunks.join(''),
-      finalReply: lastSegment,
+      finalReply: sawToolCall ? finalMessage : lastSegment,
+      incomplete,
       budget: sessionBudget(session.id),
       durationMs: Date.now() - startedAt,
       logPath,
       ts: new Date().toISOString(),
     };
     await writeStdoutJson(JSON.stringify(out) + '\n');
+    if (incomplete) process.exitCode = 1;
     return;
   }
   if (opts.enableTools) process.stdout.write(`${finalMessage}\n`);
   else process.stdout.write('\n');
+  if (incomplete) {
+    console.error('Turn ended without a final assistant reply.');
+    process.exitCode = 1;
+  }
   ui.info(`[session ${session.id.slice(0, 8)}  ${result.provider}${result.model ? '/' + result.model : ''}  ${sessionBudget(session.id)}]`);
 }
 
@@ -655,7 +690,7 @@ export function buildCliAgentTools(
   trustedWorkingDirectory?: string,
 ): {
   specs: import('../llm.js').LLMToolSpec[];
-  dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  dispatch: (name: string, args: Record<string, unknown>, context?: { signal?: AbortSignal }) => Promise<unknown>;
   workingDirectory: string;
 } {
   // An explicitly assigned child cwd is stable for its isolated lifetime. An
@@ -706,7 +741,7 @@ export function buildCliAgentTools(
   //   게이트. [[project_skill_native_duplication_surface_gating]].
   const shared = (require('../agent/shared-app-tools.js') as typeof import('../agent/shared-app-tools.js')).buildSharedAppTools(cfg);
   for (const s of shared.specs) specs.push(s);
-  for (const name of shared.names) dispatchByName.set(name, async (args) => shared.dispatch(name, args));
+  for (const name of shared.names) dispatchByName.set(name, async (args, signal) => shared.dispatch(name, args, { surface: 'tui', signal }));
   // Installed knowledge is queryable in CLI chat as well as the dashboard runtime.
   // No installed packs => preserve the existing CLI tool list and avoid creating a KGS database.
   const { kgsDefaultDbPath } = require('../knowledge/kgs/sqlite-store.js') as typeof import('../knowledge/kgs/sqlite-store.js');
@@ -751,10 +786,10 @@ export function buildCliAgentTools(
   const dispatchSessionRuntimeTool = sr.dispatchSessionRuntimeTool;
   const createPlanner = sr.createSearchPlannerState;
   const plannerState = createPlanner({ maxAutoNarrowCandidates: 2 });
-  const dispatch = async (name: string, args: Record<string, unknown>): Promise<unknown> => {
+  const dispatch = async (name: string, args: Record<string, unknown>, context?: { signal?: AbortSignal }): Promise<unknown> => {
     try {
       const direct = dispatchByName.get(name);
-      if (direct) return await direct(args);
+      if (direct) return await direct(args, context?.signal);
       // ⭐ BACKLOG L1b (2026-09-25) — ToolSearch 는 지연 도구가 있으면 «자동으로 광고»되는데 이 CLI 디스패처만
       //   라우팅이 없어 `plugin tool unavailable in CLI: ToolSearch` 로 죽었다(daemon·monad-agent-turn 은 라우팅한다).
       //   ⇒ 같은 공용 라우터로 이 CLI 의 도구 풀에서 찾는다.

package/src/cli/intake-cli.ts

@@ -5,7 +5,7 @@ import type { Command } from 'commander';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { readNexusRuntime } from '../nexus/runtime.js';
 import { resolveRoleLlm } from '../user-config.js';
-import { runIntakeToTasks, type IntakeTaskInput, type IntakeTaskRequest, type IntakeToTasksResult } from '../intake-plane/intake-to-tasks.js';
+import { approveChannelPublish, runIntakeToTasks, type IntakeTaskInput, type IntakeTaskRequest, type IntakeToTasksResult } from '../intake-plane/intake-to-tasks.js';
 import { writeStdoutJson } from './stdout-json.js';
 import { writeStdoutFully } from './stdout-flush.js';
 import { runGitCommand } from '../git-fs/runner.js';
@@ -37,6 +37,8 @@ export interface IntakeCliDeps extends IntakeCandidatesCliDeps {
   root?: string;
   /** 텔레그램 «저장된 메시지» 연결 (기본 gramjsFetchSaved) — 시험은 가짜 fetch 를 넣는다. */
   connectSaved?: () => Promise<{ fetch: FetchSavedMessages; close: () => Promise<void> }>;
+  /** 수집 연결 실패를 CLI 사용자에게 보고한다. */
+  error?: (message: string) => void;
 }
 
 /** `--limit` 원 문자열 → 0 이상의 정수. 숫자만(`/^\d+$/`) 받고 나머지('' · 공백 · 음수 · 소수)는 거부한다. */
@@ -535,6 +537,24 @@ export function registerIntakeCommands(program: Command, candidateDeps: IntakeCl
       if (result.failed > 0) process.exitCode = 1;
     });
 
+  intakeCmd
+    .command('approve-channel-post <id>')
+    .description('보호 범주의 채널 게시 초안을 사람 승인한다 (외부 게시 커넥터는 호출하지 않는다)')
+    .requiredOption('--by <approver>', '승인자: MK | 대표')
+    .option('--json', '구조화 출력')
+    .action(async (id: string, opts: { by: string; json?: boolean }) => {
+      const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+      const approved = approveChannelPublish(candidateDeps.root ?? effectiveInstanceRoot(), id, opts.by);
+      if (!approved) {
+        console.error(`대기 중인 보호 초안을 찾지 못했거나 승인자(${opts.by})가 MK·대표가 아니다: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      const result = { id, status: approved.status, approvedBy: approved.approvedBy, category: approved.category };
+      if (opts.json) await writeStdoutFully(JSON.stringify(result) + '\n');
+      else console.log(`${id} → ${approved.status} · 승인자 ${approved.approvedBy} · 외부 게시 미실행`);
+    });
+
   intakeCmd
     .command('collect-telegram-saved')
     .description('텔레그램 «저장된 메시지»를 읽기만 해 흡수 원장에 넣는다 (커서 이후만 · 호스트 전용 · 개인 메모는 user-private)')
@@ -546,6 +566,7 @@ export function registerIntakeCommands(program: Command, candidateDeps: IntakeCl
         ...(candidateDeps.root ? { root: candidateDeps.root } : {}),
         ...(candidateDeps.connectSaved ? { connect: candidateDeps.connectSaved } : {}),
         ...(candidateDeps.write ? { write: candidateDeps.write } : {}),
+        ...(candidateDeps.error ? { error: candidateDeps.error } : {}),
       });
     });
 

package/src/cli/lesson-cli.ts

@@ -2,6 +2,7 @@ import type { Command } from 'commander';
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { FrictionInputError, FrictionLedger, frictionActor, type FrictionRecordInput } from '../lessons/friction-ledger.js';
 import { importLessons, scanLessonDocs } from '../lessons/lesson-import.js';
 import { LessonInputError, LessonLedger, type LessonLedgerOptions, type LessonRow, type LessonDetail } from '../lessons/lesson-ledger.js';
 
@@ -47,6 +48,18 @@ function validAuthoringLessonClass(value: string): boolean {
 export function registerLessonCommands(program: Command, options: LessonLedgerOptions = {}, out: Pick<Console, 'log'> = console): void {
   const root = program.command('lesson').description('사고 · 원인 · 처방 · 재발 교훈 원장');
   const ledger = () => new LessonLedger(options);
+  // 손 걸음 원장은 그림자 기록이다: 비밀 꼴 note 는 빼고 남기며, 어떤 경우에도 lesson 명령을 실패시키지 않는다.
+  const recordFriction = (input: FrictionRecordInput): void => {
+    const friction = new FrictionLedger(options);
+    const attempts = input.note ? [input, { ...input, note: '' }] : [input];
+    for (const attempt of attempts) {
+      try { friction.record(attempt); return; }
+      catch (error) {
+        debug.log('lessons.friction', 'skipped', { kind: attempt.kind, signature: attempt.signature,
+          reason: error instanceof FrictionInputError ? error.message : String(error) });
+      }
+    }
+  };
   const emit = (value: unknown, json: boolean | undefined, text: string) => out.log(json ? JSON.stringify(value) : text);
   root.command('import').description('INCIDENT·FINDING 문서 교훈 미리 보기 (기본값); --apply 로 적재')
     .option('--apply', '원장에 적재').option('--json', 'JSON 출력').option('--by <name>', '기록자 (기본 AI_AGENT)')
@@ -128,11 +141,12 @@ export function registerLessonCommands(program: Command, options: LessonLedgerOp
         return;
       }
       const required = ['incident', 'cause', 'remedy', 'owner', 'source'] as const;
+      const lessonId = id ?? '';
       const missing: string[] = required.filter((key) => typeof o[key] !== 'string' || !(o[key] as string).trim());
-      if (!id?.trim()) missing.unshift('id');
+      if (!lessonId.trim()) missing.unshift('id');
       if (missing.length) throw new LessonInputError(`required: ${missing.map(key => key === 'id' ? 'id' : `--${key}`).join(', ')}`);
       const by = actor(typeof o.by === 'string' ? o.by : undefined);
-      const row = ledger().add({ id, incident: o.incident as string, cause: o.cause as string, remedy: o.remedy as string,
+      const row = ledger().add({ id: lessonId, incident: o.incident as string, cause: o.cause as string, remedy: o.remedy as string,
         owner: o.owner as string, source: o.source as string, by,
         ...(o.enforcedBy !== undefined ? { enforcedBy: o.enforcedBy as string } : {}),
         ...(o.disproof !== undefined ? { disproof: o.disproof as string } : {}) });
@@ -140,7 +154,9 @@ export function registerLessonCommands(program: Command, options: LessonLedgerOp
     }));
   root.command('recur <id>').requiredOption('--source <path>').option('--note <text>').option('--by <name>')
     .action(handle('recur', (id: string, o: { source: string; note?: string; by?: string }) => {
-      const row = ledger().recur(id, { source: o.source, note: o.note ?? '', by: actor(o.by) });
+      const by = actor(o.by);
+      const row = ledger().recur(id, { source: o.source, note: o.note ?? '', by });
+      recordFriction({ actor: frictionActor(by), kind: 'hand-step', signature: row.incident ?? `lesson ${row.id}`, note: o.note ?? '', ref: o.source });
       emit(row, false, format(row));
     }));
   root.command('enforce <id>').requiredOption('--enforced-by <paths>').option('--by <name>')

package/src/cli/log-event-names.ts

@@ -201,6 +201,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "chain-step-failed",
   "change",
   "chat-error",
+  "chat-history-compacted",
   "chat-input-consumed",
   "chat-main",
   "chat-main.await",
@@ -1075,6 +1076,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "read-error",
   "read.path-resolved",
   "readiness-threw",
+  "readonly-tool-repeat-suppressed",
   "ready",
   "ready.timeout",
   "rebuild",
@@ -1140,6 +1142,9 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "reply.tts.ok",
   "request",
   "request-received",
+  "request-size",
+  "request-size-compact",
+  "request-size-compact-error",
   "request-watch-fail",
   "request.error",
   "request.out",
@@ -1362,6 +1367,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "status",
   "status-ledger",
   "status-port-resolved",
+  "status-question-interim-reprompt",
   "stdin-backpressure",
   "stdout",
   "step",

package/src/cli/mcp-login.ts

@@ -11,6 +11,8 @@ import {
   prepareMcpOAuthAuthorization,
   authorizeMcpDevice,
   type McpOAuthFetch,
+  type AuthorizationServerMetadata,
+  type ProtectedResourceMetadata,
 } from '../mcp/mcp-oauth.js';
 import { parseWwwAuthenticate } from '../mcp/client.js';
 import { debug } from '../debug/log.js';
@@ -129,6 +131,7 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
       early: callbackListener,
       serverId: opts.serverId,
       resourceMetadataUrl: challenge.resourceMetadata,
+      discovered,
       ...(challenge.scope ? { scope: challenge.scope } : {}),
       resourceUrl: spec.url,
       ...oauthOpts,
@@ -245,6 +248,7 @@ function loginFailureStage(error: unknown): 'authorization' | 'token' | 'login'
 async function openLoginListener(opts: {
   serverId: string;
   resourceMetadataUrl: string;
+  discovered: { resource: ProtectedResourceMetadata; metadata: AuthorizationServerMetadata };
   scope?: string;
   resourceUrl: string;
   fetch?: McpOAuthFetch;
@@ -253,13 +257,14 @@ async function openLoginListener(opts: {
   onListener?: (server: Server) => void;
   early: Awaited<ReturnType<typeof listenForCallback>>;
 }): Promise<{ listener: Awaited<ReturnType<typeof listenForCallback>>; authorization: Awaited<ReturnType<typeof prepareMcpOAuthAuthorization>> }> {
-  const prior = await priorRegistration(opts);
+  const prior = loadStoredRegistration(opts.discovered.metadata.issuer, opts);
   const preferred = loopbackRedirectPort(prior?.redirectUri);
   if (preferred === null && (prior === null || prior.redirectUri)) {
     const listener = opts.early;
     debug.log('mcp.login', 'callback-port', { serverId: opts.serverId, source: 'fresh' });
     const authorization = await prepareMcpOAuthAuthorization({
       resourceMetadataUrl: opts.resourceMetadataUrl,
+      discovered: opts.discovered,
       scope: opts.scope,
       redirectUri: listener.redirectUri,
       resourceUrl: opts.resourceUrl,
@@ -276,6 +281,7 @@ async function openLoginListener(opts: {
       debug.log('mcp.login', 'callback-port', { serverId: opts.serverId, source: 'registered' });
       const authorization = await prepareMcpOAuthAuthorization({
         resourceMetadataUrl: opts.resourceMetadataUrl,
+        discovered: opts.discovered,
         scope: opts.scope,
         redirectUri: listener.redirectUri,
         resourceUrl: opts.resourceUrl,
@@ -296,6 +302,7 @@ async function openLoginListener(opts: {
   });
   const authorization = await prepareMcpOAuthAuthorization({
     resourceMetadataUrl: opts.resourceMetadataUrl,
+    discovered: opts.discovered,
     scope: opts.scope,
     redirectUri: listener.redirectUri,
     resourceUrl: opts.resourceUrl,
@@ -306,23 +313,6 @@ async function openLoginListener(opts: {
   return { listener, authorization };
 }
 
-async function priorRegistration(opts: {
-  resourceMetadataUrl: string;
-  resourceUrl: string;
-  fetch?: McpOAuthFetch;
-  storePath?: string;
-}): Promise<ReturnType<typeof loadStoredRegistration>> {
-  try {
-    const discovered = await discoverMcpOAuth(opts.resourceMetadataUrl, {
-      resourceUrl: opts.resourceUrl,
-      ...(opts.fetch ? { fetch: opts.fetch } : {}),
-    });
-    return loadStoredRegistration(discovered.metadata.issuer, opts);
-  } catch {
-    return null;
-  }
-}
-
 function isAddressInUse(error: unknown): boolean {
   return Boolean(error && typeof error === 'object' && 'code' in error && (error as { code: unknown }).code === 'EADDRINUSE');
 }

package/src/cli/msg-cli.ts

@@ -1,13 +1,20 @@
 import type { Command } from 'commander';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
 import { ensureAuthToken } from '../auth/acp-token.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { canonicalSeatId, openMsgStore, openMsgStoreReadOnly, type Message, type MsgStore } from '../msg/msg-store.js';
 import { clearPostOffice, ensurePostOffice, writePostOffice } from '../msg/msg-post-office.js';
+import { acquireLockSync } from '../storage/file-lock.js';
+import { GitHubMsgMirrorTransport } from '../msg/msg-mirror-github.js';
+import { configuredMirrorTarget, runMsgMirrorTick, type MirrorTarget, type MsgMirrorStateStore, type MsgMirrorTransport } from '../msg/msg-mirror-runner.js';
+import { JsonMsgMirrorStateStore } from '../msg/msg-mirror-state.js';
 import { startMsgSseServer } from '../msg/msg-sse-server.js';
+import { debug } from '../debug/log.js';
 import type { AgentReplyAddress, AgentReplyInput, AgentReplyResult } from '../loops/agent-reply.js';
 import { messageRouteFor, noReplyBodyNotice, unsupportedLoopAddressNotice } from '../loops/msg-address.js';
 import { resolveWake, wakeRecipient, type WakeDeps, type WakeOutcome } from '../loops/msg-wake.js';
-import type { RoleLlmSpec } from '../user-config.js';
+import { getUserConfig, type RoleLlmSpec } from '../user-config.js';
 
 /** The loop rows whose reply body is an LLM agent: `--agent-reply` picks one of these. */
 const AGENT_REPLY_ROLES = { COORDINATOR: 'coordinator', GUARDIAN: 'guardian' } as const;
@@ -22,6 +29,9 @@ export interface MsgCliDeps {
   signal?: AbortSignal;
   fetch?: typeof fetch;
   authToken?: () => string;
+  mirrorTarget?: MirrorTarget | null;
+  mirrorState?: MsgMirrorStateStore;
+  mirrorTransport?: MsgMirrorTransport;
   /** Wake-path resolution for `msg route` (tests inject; default reads pty manifest ⊕ seat folders). */
   wakeDeps?: WakeDeps;
   /** Attach the logs.db sink so `msg.wake` reaches `elanous logs` (a short CLI otherwise writes only the file trail). */
@@ -198,6 +208,52 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
     if (address !== to) throw new Error(`--agent-reply ${address} requires --to ${address}`);
   };
 
+  msg.command('mirror').description('Mirror selected seat messages to the configured GitHub issue')
+    .option('--dry-run', 'read the configured channel and ledger without writing')
+    .option('--watch', 'repeat until interrupted')
+    .option('--interval <seconds>', 'poll interval in watch mode (default 60)', '60')
+    .option('--json')
+    .action((opts: CommonOptions & { dryRun?: boolean; watch?: boolean; interval?: string }) => run(async () => {
+      const intervalSeconds = integer(opts.interval, '--interval', 60, 1, 3600);
+      const state = deps.mirrorState ?? new JsonMsgMirrorStateStore();
+      const configTarget = deps.mirrorTarget === undefined
+        ? configuredMirrorTarget(getUserConfig().raw.msgMirror) : deps.mirrorTarget ?? undefined;
+      const existingState = state.read();
+      if (!configTarget && !existingState) {
+        const result = { status: 'disabled', reason: 'msgMirror.target is not configured', target: null };
+        debug.log('msg.mirror', 'disabled', result);
+        out.log(opts.json ? JSON.stringify(result) : 'msg mirror 비활성: msgMirror.target 미설정');
+        return;
+      }
+      const store = openRead();
+      const transport = deps.mirrorTransport ?? new GitHubMsgMirrorTransport();
+      const signal = deps.signal;
+      try {
+        do {
+          let release = () => {};
+          if (state instanceof JsonMsgMirrorStateStore) {
+            mkdirSync(dirname(state.path), { recursive: true, mode: 0o700 });
+            release = acquireLockSync(`${state.path}.lock`, { breakDeadHolder: true });
+          }
+          let result: Awaited<ReturnType<typeof runMsgMirrorTick>>;
+          try {
+            result = await runMsgMirrorTick({
+              ...(configTarget ? { configuredTarget: configTarget } : {}),
+              ...(opts.dryRun ? { dryRun: true } : {}),
+              source: { listAfter: (after, limit) => store.listAfter(after, limit),
+                listWindow: (start, end) => store.listCreatedBetween(start, end), latestId: () => store.latestId() },
+              state, transport,
+            });
+          } finally { release(); }
+          debug.log('msg.mirror', 'tick', result);
+          out.log(opts.json ? JSON.stringify(result)
+            : `msg mirror ${result.status} · scanned ${result.scanned} · posted ${result.posted} · rotated ${result.rotated} · summaries ${result.summaries}`);
+          if (!opts.watch || signal?.aborted) break;
+          await sleep(intervalSeconds * 1000);
+        } while (!signal?.aborted);
+      } finally { store.close(); }
+    })());
+
   /**
    * Human-free live conversation: the selected address's LLM body answers the message that was just saved.
    * The durable ledger stays authoritative — `replyWithAgent` owns the one-reply-per-request transaction and

package/src/cli/pod-cli.ts

@@ -14,7 +14,7 @@ import { getUserConfig } from '../user-config.js';
 import { listCodexAccountsInStore } from '../oauth/codex-account-store.js';
 import { parsePodPool, resolvePodPoolSpec, podPoolHostLease, type PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
 import { leaseKubectl, measurePoolLease, probePoolDns, probePoolGitHub, recommendConcurrency, type PoolLeaseMeasure, type PoolDnsProbe, type ExternalGitHubProbe } from '../task-orchestrator/surfaces/pod-lease.js';
-import { POD_COMMAND_DEADLINE_SECONDS, runPodCommand, type PodCommandResult, type RunPodCommandOptions } from '../task-orchestrator/surfaces/pod-command-job.js';
+import { POD_COMMAND_DEADLINE_SECONDS, parseCpuRightsizeRequest, runPodCommand, type PodCommandResult, type PodCpuRightsizeRequest, type RunPodCommandOptions } from '../task-orchestrator/surfaces/pod-command-job.js';
 import { hostLeaseCounts, leaseHasPendingPod } from '../pod-lease/host-lease.js';
 
 export interface PodCliIo {
@@ -220,7 +220,8 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
     .allowUnknownOption(true)
     .allowExcessArguments(true)
     .option('--lite', '네트워크 스킬(omni-crawl·omni-digest)만 쓰는 명령 — 작은 이미지 ⊕ 2Gi 한도(POD7 · clone 불가)')
-    .action(async (opts: { pool?: string; skill?: string; llm?: string; clone?: boolean; deadline?: string; lite?: boolean }, command: Command) => {
+    .option('--cpu-rightsize <json>', 'POD-CPU-REQUEST-RIGHTSIZE-2-FU: 공존 재측정 요청(JSON 파일 경로 또는 인라인 JSON) — { condition?, samples[], priorLaunches[] }. 선행 조건·측정이 모자라면 발사하지 않는다')
+    .action(async (opts: { pool?: string; skill?: string; llm?: string; clone?: boolean; deadline?: string; lite?: boolean; cpuRightsize?: string }, command: Command) => {
       const argv = process.argv.slice(2);
       const sep = argv.indexOf('--');
       const fromArgv = sep >= 0 ? argv.slice(sep + 1) : [];
@@ -244,6 +245,19 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
           return;
         }
       }
+      // POD-CPU-REQUEST-RIGHTSIZE-2-FU — the OP-facing measurement launch reads its request from JSON (file path or inline).
+      let cpuRightsize: PodCpuRightsizeRequest | undefined;
+      if (opts.cpuRightsize !== undefined) {
+        try {
+          const source = opts.cpuRightsize.trim();
+          const text = source.startsWith('{') ? source : readFileSync(source, 'utf8');
+          cpuRightsize = parseCpuRightsizeRequest(JSON.parse(text), '--cpu-rightsize');
+        } catch (err) {
+          io.error(`pod run: --cpu-rightsize — ${err instanceof Error ? err.message : String(err)}`);
+          io.exit(2);
+          return;
+        }
+      }
       const skills = (opts.skill ?? '').split(',').map((s) => s.trim()).filter(Boolean);
       const cloneWarning = podCloneWithoutInstallWarning(commandArgs, opts.clone);
       if (cloneWarning !== null) {
@@ -268,6 +282,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
           ...(opts.llm === 'grok' ? { llm: 'grok' as const } : {}),
           ...(opts.clone ? { clone: true } : {}),
           ...(opts.lite ? { lite: true } : {}),
+          ...(cpuRightsize ? { cpuRightsize } : {}),
           ...(deadlineSeconds !== undefined ? { deadlineSeconds } : {}),
         });
         if (result.image) io.error(`[pod] image ${result.image} · job ${result.job}`);