elanous 0.2.6 → 0.2.8

package/src/cli/msg-cli.ts

@@ -0,0 +1,137 @@
+import type { Command } from 'commander';
+import { canonicalSeatId, openMsgStore, type Message, type MsgStore } from '../msg/msg-store.js';
+
+export interface MsgCliDeps {
+  openStore?: () => MsgStore;
+  out?: Pick<Console, 'log' | 'error'>;
+  readStdin?: () => Promise<string>;
+  sleep?: (ms: number) => Promise<void>;
+  setExitCode?: (code: number) => void;
+  signal?: AbortSignal;
+}
+
+type CommonOptions = { json?: boolean };
+type RecipientOptions = CommonOptions & { to?: string; after?: string; limit?: string };
+
+function seat(raw: string | undefined, flag: string): string {
+  if (raw === undefined) throw new Error(`${flag} is required`);
+  return canonicalSeatId(raw);
+}
+
+function integer(raw: string | undefined, flag: string, fallback: number, min: number, max: number): number {
+  if (raw === undefined) return fallback;
+  if (!/^(0|[1-9]\d*)$/.test(raw)) throw new Error(`${flag} must be an integer between ${min} and ${max}`);
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error(`${flag} must be an integer between ${min} and ${max}`);
+  return value;
+}
+
+function formatMessage(message: Message): string {
+  return `#${message.id} ${message.createdAt} ${message.from} → ${message.to}${message.kind ? ` [${message.kind}]` : ''}: ${message.body}`;
+}
+
+/** Register the durable, recipient-addressed CLI. Reading never advances the acknowledgement cursor. */
+export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): void {
+  const open = deps.openStore ?? (() => openMsgStore());
+  const out = deps.out ?? console;
+  const readStdin = deps.readStdin ?? (() => Bun.stdin.text());
+  const sleep = deps.sleep ?? ((ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms)));
+  const setExitCode = deps.setExitCode ?? ((code: number) => { process.exitCode = code; });
+  const msg = program.command('msg').description('Durable seat-addressed messages');
+
+  const run = (action: () => void | Promise<void>) => async () => {
+    try { await action(); }
+    catch (error) {
+      out.error(`msg: ${error instanceof Error ? error.message : String(error)}`);
+      setExitCode(2);
+    }
+  };
+  const withStore = <T>(action: (store: MsgStore) => T): T => {
+    const store = open();
+    try { return action(store); }
+    finally { store.close(); }
+  };
+  const emit = (value: unknown, json: boolean | undefined, human: () => void) => {
+    if (json) out.log(JSON.stringify(value));
+    else human();
+  };
+
+  msg.command('post [body]').description('Post a message; use - or omit body to read stdin')
+    .option('--from <seat>').option('--to <seat>').option('--kind <kind>').option('--body <text>').option('--json')
+    .action((body: string | undefined, opts: CommonOptions & { from?: string; to?: string; kind?: string; body?: string }) => run(async () => {
+      const from = seat(opts.from, '--from');
+      const to = seat(opts.to, '--to');
+      if (body !== undefined && body !== '-' && opts.body !== undefined) throw new Error('provide body once (argument or --body)');
+      const text = opts.body ?? (body !== undefined && body !== '-' ? body : await readStdin());
+      const posted = withStore(store => store.post({ from, to, body: text, ...(opts.kind === undefined ? {} : { kind: opts.kind }) }));
+      emit(posted, opts.json, () => out.log(formatMessage(posted)));
+    })());
+
+  msg.command('list').description('List messages for one recipient without acknowledging them')
+    .option('--to <seat>').option('--after <id>', 'exclusive message ID (default: acknowledged cursor)')
+    .option('--limit <count>', 'maximum messages (1–1000)').option('--json')
+    .action((opts: RecipientOptions) => run(() => {
+      const to = seat(opts.to, '--to');
+      const limit = integer(opts.limit, '--limit', 100, 1, 1000);
+      const after = opts.after === undefined ? undefined : integer(opts.after, '--after', 0, 0, Number.MAX_SAFE_INTEGER);
+      const messages = withStore(store => store.list(to, after ?? store.getCursor(to), limit));
+      emit(messages, opts.json, () => {
+        if (!messages.length) out.log('No messages.');
+        for (const message of messages) out.log(formatMessage(message));
+      });
+    })());
+
+  msg.command('ack [id]').description('Explicitly acknowledge messages through this ID for one recipient')
+    .option('--to <seat>').option('--json')
+    .action((id: string | undefined, opts: CommonOptions & { to?: string }) => run(() => {
+      const to = seat(opts.to, '--to');
+      if (id === undefined) throw new Error('message ID is required');
+      const cursor = integer(id, 'message ID', 0, 0, Number.MAX_SAFE_INTEGER);
+      const acknowledged = withStore(store => store.ack(to, cursor));
+      emit({ recipient: to, cursor: acknowledged }, opts.json, () => out.log(`${to} acknowledged through #${acknowledged}`));
+    })());
+
+  msg.command('unread').description('Show recipients with unacknowledged messages')
+    .option('--to <seat>').option('--json')
+    .action((opts: CommonOptions & { to?: string }) => run(() => {
+      const to = opts.to === undefined ? undefined : seat(opts.to, '--to');
+      const rows = withStore(store => store.unread().filter(row => to === undefined || row.recipient === to));
+      emit(rows, opts.json, () => {
+        if (!rows.length) out.log('No unread messages.');
+        for (const row of rows) out.log(`${row.recipient}: ${row.count} unread`);
+      });
+    })());
+
+  msg.command('watch').description('Poll for new messages without acknowledging them (Ctrl-C to stop)')
+    .option('--to <seat>').option('--after <id>', 'exclusive message ID (default: acknowledged cursor)')
+    .option('--interval <ms>', 'poll interval in milliseconds', '1000')
+    .option('--once', 'poll once and exit').option('--json')
+    .action((opts: RecipientOptions & { interval?: string; once?: boolean }) => run(async () => {
+      const to = seat(opts.to, '--to');
+      const interval = integer(opts.interval, '--interval', 1000, 1, 60000);
+      const after = opts.after === undefined ? undefined : integer(opts.after, '--after', 0, 0, Number.MAX_SAFE_INTEGER);
+      const store = open();
+      try {
+        let cursor = after ?? store.getCursor(to);
+        do {
+          let messages: Message[];
+          do {
+            messages = store.list(to, cursor, 1000);
+            for (const message of messages) {
+              emit(message, opts.json, () => out.log(formatMessage(message)));
+              cursor = message.id;
+            }
+          } while (messages.length === 1000 && !deps.signal?.aborted);
+          if (opts.once || deps.signal?.aborted) break;
+          await sleep(interval);
+        } while (!deps.signal?.aborted);
+      } finally { store.close(); }
+    })());
+
+  // Commander reports option/argument errors before action handlers run. Scope their exit code
+  // to msg so unrelated commands keep their own error and help behavior.
+  for (const command of [msg, ...msg.commands]) {
+    const reportError = command.error.bind(command);
+    command.error = (message, options) => reportError(message, { ...options, exitCode: 2 });
+  }
+}

package/src/cli/persona-cli.ts

@@ -0,0 +1,116 @@
+// PS1 — `elanous persona list|add|show`: 프리셋(persona-presets/)을 보고, 골라서 «내 페르소나»를 만들고, 만든 것을 본다.
+// 만든 페르소나는 기존 페르소나 저장소(resolveStatePersonaDir · Discord·PWA 가 읽는 곳)의 `<id>.yaml` 한 파일이다.
+import type { Command } from 'commander';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { debug } from '../debug/log.js';
+import { parsePersonaYaml } from '../persona/loader.js';
+import { resolveRepositoryPersonaDir, resolveStatePersonaDir } from '../persona/global-registry.js';
+import { choosePersonaId, describePreset, findPreset, loadPresetIndex, loadPresets, presetToProfileYaml } from '../persona/presets.js';
+
+interface StoredPersona { personaId: string; displayName: string; description?: string; preset?: string; title?: string; path: string }
+
+/** Personas the person made (state dir), parsed with the same loader the runtime uses. */
+export function readStoredPersonas(dir = resolveStatePersonaDir()): StoredPersona[] {
+  if (!existsSync(dir)) return [];
+  const out: StoredPersona[] = [];
+  for (const file of readdirSync(dir).filter((f) => f.endsWith('.yaml') && !f.startsWith('_')).sort()) {
+    const path = join(dir, file);
+    const text = readFileSync(path, 'utf8');
+    const parsed = parsePersonaYaml(text, path);
+    if (!parsed.ok) continue;
+    const origin = (parseYaml(text) as { preset?: { id?: unknown; title?: unknown } } | null)?.preset;
+    const preset = typeof origin?.id === 'string' ? origin.id : undefined;
+    const title = typeof origin?.title === 'string' ? origin.title : undefined;
+    out.push({ personaId: parsed.profile.personaId, displayName: parsed.profile.displayName, ...(parsed.profile.description ? { description: parsed.profile.description } : {}), ...(preset ? { preset } : {}), ...(title ? { title } : {}), path });
+  }
+  return out.sort((a, b) => a.personaId.localeCompare(b.personaId));
+}
+
+function takenIds(stateDir: string): Set<string> {
+  const ids = new Set(readStoredPersonas(stateDir).map((p) => p.personaId));
+  const repo = resolveRepositoryPersonaDir();
+  if (existsSync(repo)) for (const f of readdirSync(repo)) if (f.endsWith('.yaml')) ids.add(f.slice(0, -5));
+  if (existsSync(stateDir)) for (const f of readdirSync(stateDir)) if (f.endsWith('.yaml')) ids.add(f.slice(0, -5));
+  return ids;
+}
+
+export function registerPersonaCommands(program: Command): void {
+  const persona = program.command('persona').description('Persona presets — AI coworkers you pick and customise (list · add · show)');
+
+  persona.command('list')
+    .description('List the persona presets, then the personas you have made')
+    .option('--json', 'JSON output')
+    .action((opts: { json?: boolean }) => {
+      const presets = loadPresets();
+      const mine = readStoredPersonas();
+      debug.log('persona.cli', 'list', { presets: presets.length, mine: mine.length });
+      if (opts.json) { console.log(JSON.stringify({ presets: presets.map((p) => ({ id: p.personaId, displayName: p.displayName, role: p.role, oneLine: p.oneLine })), mine }, null, 2)); return; }
+      if (!presets.length) console.log('페르소나 프리셋을 찾지 못했습니다(persona-presets/ 가 이 설치본에 없습니다).');
+      else {
+        console.log('프리셋 — 골라서 내 페르소나로 만들기: elanous persona add <프리셋> [--name <이름>]');
+        const width = Math.max(...presets.map((p) => p.personaId.length));
+        for (const p of presets) console.log(`  ${p.personaId.padEnd(width)}  ${p.displayName} — ${p.role} · ${p.oneLine}`);
+      }
+      const made = mine.filter((p) => p.preset);
+      if (made.length) {
+        console.log('\n내 페르소나:');
+        for (const p of made) console.log(`  ${p.personaId}  ${p.displayName}${p.title ? ` (${p.title})` : ''}  (프리셋 ${p.preset})`);
+      }
+    });
+
+  persona.command('add <preset>')
+    .description('Make your own persona from a preset (id, name or role) — the preset file is not changed')
+    .option('--name <name>', 'What to call it (default: the preset’s first name)')
+    .option('--title <title>', 'Optional title, e.g. CMO')
+    .option('--json', 'JSON output')
+    .action((query: string, opts: { name?: string; title?: string; json?: boolean }) => {
+      const presets = loadPresets();
+      const preset = findPreset(presets, query);
+      if (!preset) {
+        console.error(`프리셋 «${query}» 을 찾지 못했습니다. 있는 것: ${presets.map((p) => p.personaId).join(', ')}`);
+        process.exitCode = 1;
+        return;
+      }
+      const dir = resolveStatePersonaDir();
+      const personaId = choosePersonaId(preset, opts.name, takenIds(dir));
+      const yaml = presetToProfileYaml(preset, loadPresetIndex().common, { personaId, ...(opts.name ? { name: opts.name } : {}), ...(opts.title ? { title: opts.title } : {}) });
+      const path = join(dir, `${personaId}.yaml`);
+      // The runtime loader must accept what we write — check before it lands on disk.
+      const check = parsePersonaYaml(yaml, path);
+      if (!check.ok) { console.error(`만든 페르소나를 읽을 수 없습니다: ${check.error.message}`); process.exitCode = 1; return; }
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(path, yaml, { flag: 'wx' });
+      debug.log('persona.cli', 'added', { preset: preset.personaId, personaId, named: Boolean(opts.name) });
+      if (opts.json) { console.log(JSON.stringify({ personaId, displayName: check.profile.displayName, preset: preset.personaId, path }, null, 2)); return; }
+      console.log(`만들었습니다 — ${check.profile.displayName} (id ${personaId} · 프리셋 ${preset.personaId})`);
+      console.log(`  처음 묻는 것: ${preset.firstQuestions.join(' / ')}`);
+      console.log(`  보기: elanous persona show ${personaId}`);
+    });
+
+  persona.command('show <name>')
+    .description('Show one of your personas (id or name), or a preset')
+    .option('--json', 'JSON output')
+    .action((query: string, opts: { json?: boolean }) => {
+      const q = query.trim().toLowerCase();
+      const mine = readStoredPersonas().find((p) => p.personaId === q || p.displayName.toLowerCase().startsWith(q));
+      const presets = loadPresets();
+      if (mine) {
+        const text = readFileSync(mine.path, 'utf8');
+        const parsed = parsePersonaYaml(text, mine.path);
+        if (opts.json) { console.log(JSON.stringify({ kind: 'persona', ...mine, systemPrompt: parsed.ok ? parsed.profile.systemPrompt : undefined }, null, 2)); return; }
+        console.log(`${mine.displayName}${mine.title ? ` (${mine.title})` : ''}  (id ${mine.personaId}${mine.preset ? ` · 프리셋 ${mine.preset}` : ''})`);
+        if (mine.description) console.log(`  ${mine.description}`);
+        const preset = mine.preset ? presets.find((p) => p.personaId === mine.preset) : undefined;
+        if (preset) for (const line of describePreset(preset).slice(2)) console.log(line);
+        console.log(`  파일: ${mine.path}`);
+        return;
+      }
+      const preset = findPreset(presets, query);
+      if (!preset) { console.error(`«${query}» 페르소나도 프리셋도 없습니다. 목록: elanous persona list`); process.exitCode = 1; return; }
+      if (opts.json) { console.log(JSON.stringify({ kind: 'preset', ...preset }, null, 2)); return; }
+      console.log('(프리셋 — 아직 만들지 않았습니다. 만들기: elanous persona add ' + preset.personaId + ')');
+      for (const line of describePreset(preset)) console.log(line);
+    });
+}

package/src/cli/plugin-cli.ts

@@ -12,6 +12,7 @@ import { OFFICIAL_INDEX_KEYS } from '../market/official-keys.js';
 import { installPlugin, listInstalledPlugins, PluginInstallError, removePlugin, type InstallEvent } from '../plugins/install/plugin-install.js';
 import { credentialStatus, setPluginCredentials } from '../plugins/install/plugin-credentials.js';
 import { makePlugin } from '../plugins/maker/plugin-maker.js';
+import { addAndInstallNode } from '../plugins/maker/node-install.js';
 
 function keys(): ReadonlyArray<{ keyId: string; publicKey: string }> {
   const configPath = userConfigPath();
@@ -83,6 +84,30 @@ export function registerPluginCommands(program: Command): void {
         process.exitCode = 1;
       }
     });
+  plugin.command('node').description('Manage plugin workflow nodes')
+    .command('add <dir> <request>').description('Write, validate and install a workflow node in a plugin')
+    .option('--kind <slug>', 'Workflow node kind')
+    .option('--yes', 'Accept requested capabilities')
+    .option('--json', 'Print the result as one JSON line')
+    .action(async (dir: string, request: string, opts: { kind?: string; yes?: boolean; json?: boolean }) => {
+      try {
+        const result = await addAndInstallNode({ dir, request, kind: opts.kind, yes: opts.yes,
+          deps: { consent: capabilities => askConsent(capabilities, !!opts.json) } });
+        if (opts.json) stdout.write(JSON.stringify(result) + '\n');
+        else {
+          console.log(`작성 ${result.timings.write}ms · 검증 ${result.timings.validate}ms${result.timings.repair === undefined ? '' : ` · 수리 ${result.timings.repair}ms`}`);
+          console.log(`설치 ${result.plugin ? '완료' : result.status === 'failed' && result.timings.install === 0 ? '미실행' : '실패'} · ${result.timings.install}ms`);
+          console.log(`동기화 ${result.status === 'installed' ? '완료' : result.plugin ? '실패' : '미실행'} · ${result.timings.sync}ms`);
+          for (const error of result.errors) console.error(error);
+        }
+        if (result.status === 'failed') process.exitCode = 1;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (opts.json) stdout.write(JSON.stringify({ status: 'failed', errors: [message] }) + '\n');
+        else console.error(`plugin node add failed: ${message}`);
+        process.exitCode = 1;
+      }
+    });
   plugin.command('add <spec>').description('Install a local path, pinned git plugin or signed market plugin')
     .option('--yes', 'Accept requested capabilities')
     .option('--json', 'NDJSON progress events')

package/src/cli/pr-cli.ts

@@ -17,6 +17,7 @@ import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-g
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runPublicLeakGate } from '../../scripts/ci-public-leak-gate.js';
+import { exportLeakCheck, type ExportLeakCheck } from '../../scripts/ci-public-export-leak-gate.js';
 import { checkCommands, extractElanousCommands, type Finding as DocsCliFinding } from '../../scripts/docs-cli-check.js';
 import { runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
 import { isGoalDocumentFileName } from '../self-implement/goal-document.js';
@@ -68,6 +69,8 @@ export interface PrLandOpts {
   excludeActiveRunFiles?: boolean;
   excludeActiveRunSources?: boolean;
   landReason?: string;
+  /** Land even though changed files would leak into the public export (the reason goes in --land-reason). */
+  allowPublicLeak?: boolean;
 }
 
 export interface PrGranularityOpts {
@@ -101,6 +104,8 @@ export interface PrLandDeps {
   runDaemonPortGate?: (out: { log: (message: string) => void; error: (message: string) => void }) => boolean;
   /** 공개 유출 래칫(경고 전용) — 반환 0 통과 · 1 늘었다 · 2 못 쟀다. */
   runPublicLeakGate?: (changedFiles: readonly string[], out: { log: (message: string) => void; error: (message: string) => void }) => number;
+  /** Test seam — the post-transform export leak check on changed files. */
+  runExportLeakCheck?: (changedFiles: readonly string[], cwd: string) => ExportLeakCheck;
   /** 공개 문서의 `elanous …` 호출 ↔ 실제 `--help` 대조(경고 전용) — 바뀐 공개 문서 경로를 받아 어긋남 목록을 돌려준다. */
   runDocsCliCheck?: (docFiles: readonly string[]) => DocsCliFinding[];
   /** 변경 시험 파일 간 간섭 검사 심(시험 주입용). */
@@ -269,6 +274,35 @@ function runPrLandPublicLeakGate(changedFiles: readonly string[], out: { log: (m
   return runPublicLeakGate({ args: ['--changed-files', ...changedFiles], log: out.log, error: out.log });
 }
 
+/** The prepare check on this landing's changed files — scripts/ci-public-export-leak-gate.ts. */
+export function runPrLandExportLeakCheck(changedFiles: readonly string[], cwd: string): ExportLeakCheck {
+  const top = runGitCommand(cwd, ['rev-parse', '--show-toplevel'], { encoding: 'utf-8' });
+  return exportLeakCheck(changedFiles, top.status === 0 && String(top.stdout ?? '').trim() ? String(top.stdout).trim() : cwd);
+}
+
+/** Blocks the landing when changed files would leak into the public export, unless allowPublicLeak. Returns false to stop. */
+export function exportLeakBlock(
+  changedFiles: readonly string[] | undefined,
+  check: () => ExportLeakCheck,
+  allow: boolean,
+  out: { log: (message: string) => void; error: (message: string) => void },
+): boolean {
+  if (!changedFiles || changedFiles.length === 0) return true;
+  let result: ExportLeakCheck;
+  try { result = check(); } catch (error) { result = { measured: false, hits: [], detail: error instanceof Error ? error.message : String(error) }; }
+  record('public-export-leak', result.measured ? result.hits.length === 0 || allow : true, { measured: result.measured, hits: result.hits.length, allowed: allow && result.hits.length > 0 });
+  if (!result.measured) { out.log(`⚠ public-export-leak: 못 쟀다(${result.detail ?? '?'}) — 착지는 막지 않는다. 확인: bun scripts/public-export.ts --leak-check --files <파일…>`); return true; }
+  if (result.hits.length === 0) { out.log('✓ public-export-leak: 바뀐 파일이 공개본에 사적 흔적을 싣지 않는다(prepare 와 같은 변환 뒤).'); return true; }
+  const write = allow ? out.log : out.error;
+  write(`${allow ? '⚠' : '✗'} public-export-leak: 바뀐 파일 ${result.hits.length}곳이 공개본에 사적 흔적을 싣는다 — 다음 release prepare 가 여기서 실패한다:`);
+  for (const h of result.hits.slice(0, 20)) write(`   ${h.file}:${h.line}  ${h.marker}`);
+  if (result.hits.length > 20) write(`   … 외 ${result.hits.length - 20}곳`);
+  write('   확인: bun scripts/public-export.ts --leak-check --all --files <파일…>');
+  if (allow) { out.log('   --allow-public-leak 로 넘긴다(이유는 --land-reason).'); return true; }
+  out.error('   고치거나, 공개본과 무관한 것이 확실하면 --allow-public-leak --land-reason "<이유>" 로 넘긴다.');
+  return false;
+}
+
 export function publicLeakWarning(
   changedFiles: readonly string[] | undefined,
   gate: (changedFiles: readonly string[], out: { log: (message: string) => void; error: (message: string) => void }) => number,
@@ -1286,6 +1320,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
 
   const changedPaths = currentChangePaths(run, cwd, staged, base, out);
   publicLeakWarning(changedPaths, deps.runPublicLeakGate ?? runPrLandPublicLeakGate, out);
+  if (!exportLeakBlock(changedPaths, () => (deps.runExportLeakCheck ?? runPrLandExportLeakCheck)(changedPaths ?? [], cwd), opts.allowPublicLeak === true, out)) return 1;
   if (publicDocPaths(changedPaths, () => true).length > 0) {
     const top = run('git', ['rev-parse', '--show-toplevel'], { cwd });
     const docsRoot = top.ok && top.out.trim() ? top.out.trim() : cwd;
@@ -1549,6 +1584,7 @@ export function registerPrCommands(program: Command, deps: PrLandDeps = {}): voi
     .option('--exclude-active-run-files', '도는 런과 겹친 파일을 이번 착지에서 제외')
     .option('--exclude-active-run-sources', '⚠ 위험: --exclude-active-run-files 가 골 문서가 아닌 파일(소스)을 빼도 착지를 강행')
     .option('--land-reason <text>', '권고를 보고도 지금 내는 이유(예: 남이 기다리는 차단 해제)')
+    .option('--allow-public-leak', '바뀐 파일이 공개본에 사적 흔적을 실어도 착지(이유는 --land-reason)')
     .action(async (opts: PrLandOpts) => {
       // ⛔⭐⭐⭐ **관측 sink 를 먼저 건다** — 라이브 도그푸드가 잡은 결함(2026-08-03).
       //   단위 테스트는 `debug.log` 가 **불렸다**를 단언하지만, standalone CLI 는 sink 를 등록하지

package/src/cli/provider-cli.ts

@@ -239,6 +239,9 @@ export function registerProviderCommands(program: Command): void {
       // ⛔⭐ 「후보」는 판정기가 «자기 자신을 뺀» 것이다 — 표면이 현재 계정을 후보로 보여 주면
       //   ***있지도 않은 선택지를 말한다***(리뷰 must-fix). 판정기와 같은 기준(storeKey)으로 거른다.
       const shownCandidates = s.candidates.filter((c) => c.storeKey !== s.current.storeKey);
+      const { codexCreditPlanFromDisk } = await import('./codex-credit-plan-view.js');
+      const { formatCodexCreditPlan } = await import('../budget/codex-credit-plan.js');
+      const creditPlan = codexCreditPlanFromDisk(now);
       const ageMinOf = (home: string | undefined): number | null => {
         if (!home) return null;
         const at = home === s.currentHome ? s.currentObservedAt : s.observedAtByHome[home];
@@ -258,6 +261,7 @@ export function registerProviderCommands(program: Command): void {
       if (opts.json) {
         await writeStdoutJson(JSON.stringify({
           policy: { value: s.policy.policy, source: s.policy.source },
+          creditPlan,
           universe: {
             instanceRoot, signalDir, authStore: authStorePath(),
             // ⭐ JSON 에도 싣는다 — 화면만 알면 스크립트가 못 센다
@@ -303,6 +307,7 @@ export function registerProviderCommands(program: Command): void {
       const policySource = s.policy.source === 'legacy-credits' ? ' · 옛 codexCreditsAllowed 에서'
         : s.policy.source === 'default' ? ' · 기본값' : '';
       console.log(`정책      ${s.policy.policy} (${CODEX_QUOTA_POLICY_LABEL[s.policy.policy]} · llm.codexQuotaPolicy)${policySource}`);
+      for (const line of formatCodexCreditPlan(creditPlan)) console.log(line);
       console.log(`지금 계정 ${s.current.name}  (source=${s.current.source})`);
       console.log(`          홈=${s.currentHome ?? '(모름)'}  사용=${s.currentUsedPercent ?? '?'}%  찼나=${s.currentReached ?? '모름'}  신호=${ageOf(s.currentHome)}  크레딧=${creditText(s.currentCreditBalance, s.currentHasCredits)}`);
       console.log('후보');

package/src/cli/release-cli.ts

@@ -5,6 +5,7 @@
 //   elanous release tag --version <x.y.z> --source <commit> [--yes]
 //   elanous release verify  [--version <x.y.z>]
 //   elanous release notes   --from <ref> [--to <ref>]
+//   elanous release run     --version <x.y.z> [--dry-run] [--json] [--if-ready]
 //
 // 🩸 계기(2026-09-25 v0.1.0 첫 공개): 손으로 밟은 절차에서 둘을 빠뜨릴 뻔했다 — 공개본 git 커밋(판 커밋이 공개본 커밋이 된다) ·
 //    PWA 빌드(빌드 산출은 공개본에 안 실린다 → 빠뜨리면 «웹 화면 없는 판»). 절차를 명령으로 굳힌다.
@@ -22,8 +23,11 @@ import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { envLiteral } from '../platform/env-literal.js';
 import { userConfigPath } from '../user-config.js';
-import { addItem, devVersion, listChecklist, removeItem, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus, type ChecklistDisposition } from '../release-loop/checklist.js';
+import { addItem, devVersion, listChecklist, removeItem, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus, type ChecklistDisposition, type ChecklistKind } from '../release-loop/checklist.js';
 import { writeStdoutJson } from './stdout-json.js';
+import { runUnattendedRelease, type UnattendedReleaseDeps } from '../../scripts/release-loop/unattended-release.js';
+import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
+import { runReleaseIfReady } from './release-run-if-ready.js';
 
 export const DEFAULT_PUBLIC_REPO = 'ElanvitalAI/elanous';
 const SEMVER = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
@@ -482,7 +486,7 @@ async function checklistOutput(v: string, codenames: Record<string, string>, mod
   }
 }
 
-export function registerReleaseCommands(program: Command): void {
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}): void {
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const checklist = release.command('checklist').description('판별 확인표 조회·갱신')
     .option('--version <v>', '판 또는 별칭(기본: package.json 의 개발판에서 -dev.N 제거)')
@@ -501,20 +505,21 @@ export function registerReleaseCommands(program: Command): void {
     const { version, codenames, json } = context(cmd);
     await checklistOutput(version, codenames, 'status', json);
   });
-  withContext(checklist.command('add <id> <title>').description('칸 추가')).option('--owner <owner>', '담당').action((id: string, title: string, opts: { owner?: string }, cmd: Command) => {
+  withContext(checklist.command('add <id> <title>').description('칸 추가')).option('--owner <owner>', '담당').option('--kind <kind>', 'screen = 다섯 화면 짝 칸')
+    .action((id: string, title: string, opts: { owner?: string; kind?: string }, cmd: Command) => {
     const { version, json } = context(cmd);
-    const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}) });
+    const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.kind !== undefined ? { kind: opts.kind as ChecklistKind } : {}) });
     if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 추가`);
   });
   withContext(checklist.command('set <id>').description('칸 상태·근거·담당·처분 갱신'))
     .option('--status <status>', 'green|yellow|red|done').option('--evidence <evidence>', '근거').option('--owner <owner>', '담당')
-    .option('--disposition <disposition>', 'move|known-issue|block')
-    .action((id: string, opts: { status?: string; evidence?: string; owner?: string; disposition?: string }, cmd: Command) => {
+    .option('--disposition <disposition>', 'move|known-issue|block').option('--kind <kind>', 'screen = 다섯 화면 짝 칸')
+    .action((id: string, opts: { status?: string; evidence?: string; owner?: string; disposition?: string; kind?: string }, cmd: Command) => {
       const { version, json } = context(cmd);
       if (opts.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(opts.status)) throw new Error(`잘못된 상태: ${opts.status}`);
       if (opts.disposition !== undefined && !['move', 'known-issue', 'block'].includes(opts.disposition)) throw new Error(`잘못된 처분: ${opts.disposition}`);
-      if (opts.status === undefined && opts.evidence === undefined && opts.owner === undefined && opts.disposition === undefined) throw new Error('갱신할 칸을 지정하라');
-      const data = setItem(version, id, { ...(opts.status !== undefined ? { status: opts.status as ChecklistStatus } : {}), ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}), ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.disposition !== undefined ? { disposition: opts.disposition as ChecklistDisposition } : {}) }, process.env.ELANOUS_TRACK || 'cli');
+      if (opts.status === undefined && opts.evidence === undefined && opts.owner === undefined && opts.disposition === undefined && opts.kind === undefined) throw new Error('갱신할 칸을 지정하라');
+      const data = setItem(version, id, { ...(opts.status !== undefined ? { status: opts.status as ChecklistStatus } : {}), ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}), ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.disposition !== undefined ? { disposition: opts.disposition as ChecklistDisposition } : {}), ...(opts.kind !== undefined ? { kind: opts.kind as ChecklistKind } : {}) }, process.env.ELANOUS_TRACK || 'cli');
       if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 갱신`);
     });
   withContext(checklist.command('rm <id>').description('칸 삭제')).action((id: string, _opts: unknown, cmd: Command) => {
@@ -587,4 +592,41 @@ export function registerReleaseCommands(program: Command): void {
       const { draftReleaseNotes, readLandedCommits, renderReleaseNotes } = await import('../../scripts/release-notes.js');
       console.log(renderReleaseNotes(draftReleaseNotes(readLandedCommits(o.from, o.to), o.from, o.to)));
     });
+  release.command('run')
+    .description('릴리스 루프 실행 — 원장 직전 판과 release.loop 설정으로 그래프 입력 구성 · --dry-run 은 입력만 출력')
+    .requiredOption('--version <v>', '공개할 판(x.y.z)')
+    .option('--dry-run', '체크리스트·그래프 실행 없이 전체 입력 보기')
+    .option('--if-ready', '준비되지 않았으면 사유를 출력하고 성공으로 건너뛴다')
+    .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
+    .action(async (o: { version: string; dryRun?: boolean; ifReady?: boolean; json?: boolean }) => {
+      if (o.ifReady && !o.dryRun) {
+        try {
+          const outcome = await runReleaseIfReady(o.version, {
+            ledgerRoot: releaseRunDeps.ledgerRoot,
+            readiness: (version, options) => releaseReadiness(version, { ledgerRoot: releaseRunDeps.ledgerRoot, checklist: releaseRunDeps.checklist, ...options }),
+            run: () => runUnattendedRelease({ version: o.version }, releaseRunDeps),
+          });
+          if (outcome.skipped) {
+            if (o.json) await writeStdoutJson(`${JSON.stringify(outcome)}\n`);
+            else console.log(`· 준비 안 됨 ${o.version} · ${outcome.reason} · ${outcome.detail}`);
+            return;
+          }
+          const result = outcome.result;
+          const ok = result.dryRun || result.state?.status === 'done' || result.state?.status === 'awaiting-approval';
+          (o.json ? console.error : console.log)(`${result.dryRun ? '· 드라이런' : '▶ 릴리스 루프'} ${result.input.version} · 입력 ${JSON.stringify(result.input)}`);
+          if (o.json) await writeStdoutJson(`${JSON.stringify({ ok, ...result })}\n`);
+          if (!ok && !process.exitCode) process.exitCode = 1;
+        } catch (e) {
+          if (o.json) await writeStdoutJson(`${JSON.stringify({ ok: false, error: (e as Error).message })}\n`);
+          else console.error(`⛔ ${(e as Error).message}`);
+          process.exitCode = 1;
+        }
+        return;
+      }
+      await jsonAction(o.json, async (log) => {
+        const result = await runUnattendedRelease({ version: o.version, dryRun: o.dryRun }, releaseRunDeps);
+        log(`${result.dryRun ? '· 드라이런' : '▶ 릴리스 루프'} ${result.input.version} · 입력 ${JSON.stringify(result.input)}`);
+        return result;
+      }, (r) => r.dryRun || r.state?.status === 'done' || r.state?.status === 'awaiting-approval');
+    });
 }

package/src/cli/release-run-if-ready.ts

@@ -0,0 +1,48 @@
+import { closeSync, mkdirSync, openSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import type { ReleaseReadiness } from '../../scripts/release-loop/release-readiness.js';
+
+export type ReleaseIfReadySkip = { skipped: true; reason: Exclude<ReleaseReadiness, { ready: true }>['reason']; detail: string };
+
+export async function runReleaseIfReady<T>(version: string, deps: {
+  readiness: (version: string, options?: { isPidAlive?: (pid: number) => boolean }) => ReleaseReadiness | Promise<ReleaseReadiness>;
+  run: () => Promise<T>;
+  ledgerRoot?: string;
+  pid?: number;
+  now?: () => Date;
+}): Promise<ReleaseIfReadySkip | { skipped: false; result: T }> {
+  const skip = (readiness: Exclude<ReleaseReadiness, { ready: true }>): ReleaseIfReadySkip => {
+    const detail = readiness.reason === 'checklist-blocked'
+      ? [...readiness.details.red, ...readiness.details.undecided, ...readiness.details.blocked].join(', ')
+      : readiness.details;
+    debug.log('release-loop.readiness', readiness.reason, { version, detail });
+    return { skipped: true, reason: readiness.reason, detail };
+  };
+  const readiness = await deps.readiness(version);
+  if (!readiness.ready) return skip(readiness);
+
+  const dir = join(deps.ledgerRoot ?? releaseLedgerRoot(), 'release', version);
+  mkdirSync(dir, { recursive: true });
+  const lock = join(dir, 'run.lock');
+  let fd: number;
+  try { fd = openSync(lock, 'wx', 0o600); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+    const detail = 'run.lock already exists';
+    debug.log('release-loop.readiness', 'already-running', { version, detail });
+    return { skipped: true, reason: 'already-running', detail };
+  }
+  try {
+    writeFileSync(fd, `${JSON.stringify({ pid: deps.pid ?? process.pid, startedAt: (deps.now ?? (() => new Date()))().toISOString() })}\n`);
+    // This call still checks publication and checklist, but must not treat our own lock as another runner.
+    const insideLock = await deps.readiness(version, { isPidAlive: () => false });
+    if (!insideLock.ready) return skip(insideLock);
+    debug.log('release-loop.readiness', 'ready', { version });
+    return { skipped: false, result: await deps.run() };
+  } finally {
+    closeSync(fd);
+    rmSync(lock);
+  }
+}

package/src/cli/setup-cli.ts

@@ -1,9 +1,10 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import type { Command } from 'commander';
-import { formatDoctorReport, runDoctor, type DoctorOptions, type DoctorReport } from './doctor-cli.js';
+import { Command } from 'commander';
+import { formatDoctorReport, registerDoctorCommand, runDoctor, type DoctorOptions, type DoctorReport } from './doctor-cli.js';
 import { applyClaudePluginSetup, planClaudePluginSetup } from './claude-plugin-setup.js';
+import { recommendedSetup } from './setup-recommend.js';
 import { debug } from '../debug/log.js';
 import { getUserConfig, saveUserConfig, type UserConfig } from '../user-config.js';
 
@@ -20,6 +21,7 @@ type SetupStep = {
 
 export interface SetupCliDeps extends DoctorOptions {
   runDoctor?: (options: DoctorOptions) => DoctorReport;
+  runDoctorFix?: (args: readonly string[]) => Promise<number>;
   readFile?: (path: string) => string;
   exists?: (path: string) => boolean;
   homeDir?: () => string;
@@ -154,14 +156,16 @@ export function registerSetupCommand(program: Command, deps: SetupCliDeps = {}):
   const setup = program.command('setup')
     .description('Check OpenAI Codex setup and guide each missing credential step')
     .option('--non-interactive', 'Report setup state without prompts or writes')
-    .action(async (opts: { nonInteractive?: boolean }) => {
+    .option('--yes', 'Set a missing Codex provider and apply recommended doctor repairs without asking')
+    .action(async (opts: { nonInteractive?: boolean; yes?: boolean }) => {
       const doctor = doctorRunner(deps);
       if (opts.nonInteractive) {
         out.log(formatSetupReport(doctor, setupSteps(deps), true));
+        for (const line of recommendedSetup((deps.getUserConfig ?? getUserConfig)())) out.log(line);
         setExitCode(0);
         return;
       }
-      if (!isStdinTty()) {
+      if (!isStdinTty() && !opts.yes) {
         (out.error ?? out.log)('대화형 온보딩은 stdin TTY가 있는 자리에서만 실행할 수 있다. 무인 설정은 `elanous setup --non-interactive`를 사용하라.');
         setExitCode(1);
         return;
@@ -169,8 +173,8 @@ export function registerSetupCommand(program: Command, deps: SetupCliDeps = {}):
       let steps = setupSteps(deps);
       const provider = steps[1]!;
       if (!provider.complete) {
-        const answer = await prompt('Set llm.provider to openai-codex now? [y/N] ');
-        if (answer?.trim().toLowerCase() === 'y') {
+        const approved = opts.yes || (await prompt('Set llm.provider to openai-codex now? [y/N] '))?.trim().toLowerCase() === 'y';
+        if (approved) {
           const config = (deps.getUserConfig ?? getUserConfig)();
           (deps.saveUserConfig ?? saveUserConfig)({ ...config, llm: { ...config.llm, provider: 'openai-codex' } });
           steps = setupSteps(deps);
@@ -179,6 +183,23 @@ export function registerSetupCommand(program: Command, deps: SetupCliDeps = {}):
         }
       }
       out.log(formatSetupReport(doctor, steps, false));
+      for (const line of recommendedSetup((deps.getUserConfig ?? getUserConfig)())) out.log(line);
+      const accepted = opts.yes || (isStdinTty() && /^(?:y|yes)?$/i.test((await prompt('추천대로 켤까요? [Y/n] '))?.trim() ?? 'n'));
+      if (accepted) {
+        const runDoctorFix = deps.runDoctorFix ?? (async (args: readonly string[]) => {
+          const doctorProgram = new Command();
+          let exitCode = 0;
+          registerDoctorCommand(doctorProgram, {
+            out,
+            err: { error: (message) => (out.error ?? out.log)(message) },
+            setExitCode: (code) => { exitCode = code; },
+          });
+          await doctorProgram.parseAsync([...args], { from: 'user' });
+          return exitCode;
+        });
+        setExitCode(await runDoctorFix(['doctor', '--fix', '--yes']));
+        return;
+      }
       setExitCode(0);
     });
 

package/src/cli/setup-recommend.ts

@@ -0,0 +1,8 @@
+export function recommendedSetup(state: { chat: { fastPath: boolean } }): [string, string] {
+  return [
+    '고칠 것 고치기 — 권한·PATH·서비스 파일·파이썬 환경 등 고칠 수 있는 항목을 고칩니다(로그인·서비스 재시작은 별도): `elanous doctor --fix --yes`',
+    state.chat.fastPath
+      ? '짧은 물음은 빠르게 — 켜져 있음(chat.fastPath=true): 짧은 물음에 도구 없이 먼저 답합니다. 끄기: `elanous config set chat.fastPath false`'
+      : '짧은 물음은 빠르게 — 꺼져 있음(chat.fastPath=false): 켜면 짧은 물음에 도구 없이 먼저 답합니다. 켜기: `elanous config set chat.fastPath true`',
+  ];
+}