elanous 0.2.6 → 0.2.7

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 빌드(빌드 산출은 공개본에 안 실린다 → 빠뜨리면 «웹 화면 없는 판»). 절차를 명령으로 굳힌다.
@@ -24,6 +25,9 @@ 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 { 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 제거)')
@@ -587,4 +591,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`',
+  ];
+}

package/src/cli/usage-cli.ts

@@ -12,9 +12,13 @@ import { consumeCodexResetCredits, listCodexResetCredits } from '../budget/codex
 import { rollupRunUsage, type RunUsageInput } from '../budget/run-usage-rollup.js';
 import { LogStore, logsDbPath, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { LOGS_SINCE_OPTION, parseSince } from './logs-cli.js';
+import { formatCodexCreditPlan, type CodexCreditPlan } from '../budget/codex-credit-plan.js';
+import { codexCreditPlanFromDisk } from './codex-credit-plan-view.js';
 
 export interface UsageCliDeps {
   readonly collect?: typeof collectUnifiedUsage;
+  /** Codex credit plan (disk only). Returns null when it cannot be read. */
+  readonly creditPlan?: () => CodexCreditPlan | null;
   readonly out?: { log: (s: string) => void };
   /** Read-only LogStore query seam; returns stored llm-usage rows, newest first. */
   readonly readRunLogs?: (query: LogQuery) => LogStoreRow[];
@@ -61,6 +65,10 @@ function usageData(row: LogStoreRow): RunUsageInput | null {
   } catch { return null; }
 }
 
+function defaultCreditPlan(): CodexCreditPlan | null {
+  try { return codexCreditPlanFromDisk(); } catch { return null; }
+}
+
 export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}): void {
   const out = deps.out ?? { log: (s: string) => console.log(s) };
   const collect = deps.collect ?? collectUnifiedUsage;
@@ -71,11 +79,13 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
     .option('--json', 'JSON 출력 — 자격 값은 없다')
     .action(async (opts: { json?: boolean }) => {
       const report = await collect();
+      const creditPlan = (deps.creditPlan ?? defaultCreditPlan)();
       if (opts.json) {
-        out.log(JSON.stringify(report, null, 2));
+        out.log(JSON.stringify({ ...report, codexCreditPlan: creditPlan }, null, 2));
         return;
       }
       out.log(formatUnifiedUsage(report));
+      if (creditPlan) out.log(['', 'codex 크레딧', ...formatCodexCreditPlan(creditPlan).map((l) => `  ${l}`)].join('\n'));
     });
 
   usage

package/src/codex/setup.ts

@@ -62,14 +62,33 @@ export interface CodexSetupResult {
 
 // ── Picker helpers (shared with onboarding) ──────────────────────────
 
-export async function pickCodexAuthMode(io: WizardIO): Promise<CodexAuthMode> {
-  const existing = loadTokens('openai-codex');
-  if (existing) {
-    const exp = existing.tokens.expiresAt;
-    const when = exp != null
-      ? (Date.now() > exp ? 'EXPIRED' : `${Math.round((exp - Date.now()) / 60000)}min left`)
-      : 'no expiry tracked';
-    io.print(`  OAuth tokens already on file (${when}).`);
+export interface CodexAuthModeDeps {
+  loadTokens?: typeof loadTokens;
+  /** OB1 — a codex CLI login (~/.codex/auth.json) the runtime already uses; default = `inspectSubscription`. */
+  hasCodexCliLogin?: () => boolean;
+}
+
+export async function pickCodexAuthMode(io: WizardIO, deps: CodexAuthModeDeps = {}): Promise<CodexAuthMode> {
+  const existing = (deps.loadTokens ?? loadTokens)('openai-codex');
+  // OB1 (10-01): a user already signed in to the codex CLI was sent through the device-code flow again,
+  // because only elanous's own token store counted. The runtime reads ~/.codex/auth.json, so it counts too.
+  // Same judgment as the runtime (`codexOAuthAvailable` in llm.ts) — two judgments drifting apart was the bug.
+  const codexCli = !existing && (deps.hasCodexCliLogin ?? (() => {
+    try {
+      const { codexOAuthAvailable } = require('../llm.js') as typeof import('../llm.js');
+      return codexOAuthAvailable();
+    } catch { return false; }
+  }))();
+  if (existing || codexCli) {
+    if (existing) {
+      const exp = existing.tokens.expiresAt;
+      const when = exp != null
+        ? (Date.now() > exp ? 'EXPIRED' : `${Math.round((exp - Date.now()) / 60000)}min left`)
+        : 'no expiry tracked';
+      io.print(`  OAuth tokens already on file (${when}).`);
+    } else {
+      io.print('  Found your ChatGPT/Codex login from the codex CLI (~/.codex/auth.json).');
+    }
     // Sprint 11 — chooseFrom Yes/No so fullScreenIO renders the arrow
     // picker (with 'y'/'n' + 한글 자모 quick-pick from PR #986 + #988)
     // instead of a bare text input. The runner distinguishes 'oauth-keep'

package/src/dashboard/index.ts

@@ -16779,7 +16779,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             preferHistoryArrowKeys: slashQuickMode,
             history: inputHistory,
             placeholder: anyProviderAvailable()
-              ? '/command, or type a question (inline /path/to.pdf to attach)'
+              ? '말 한 줄로 시작 — 질문하거나 «하니스로 구현 …» · /command · /path/to.pdf 첨부'
               : '/quit /clear (run `elanous setup` — no LLM provider available)',
             debugLog: debug.enabled ? (event, label, payload) => debug.log(event, label, payload) : undefined,
             textInputOpts: {

package/src/discord.ts

@@ -23,6 +23,8 @@
 import { markdownToTelegramHtml as _unusedMarkdownFn } from './telegram-format.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { debug } from './debug/log.js';
 import { getUserConfig } from './user-config.js';
+import { handleDiscordSeatWork, type DiscordSeatWorkDeps } from './intake-plane/discord-seat-work.js';
+import { parseSeatAddress } from './seat-address/seat-address.js';
 
 // Telegram's HTML markdown isn't directly useful for Discord (Discord
 // uses CommonMark + its own subset). Import kept as a reminder that
@@ -163,6 +165,8 @@ export interface DiscordBotOpts {
    *  primary `onMessage` LLM chat path. Errors are swallowed by the
    *  caller — this is a best-effort fan-out. */
   onTriggerTap?: (event: DcTriggerEvent) => void | Promise<void>;
+  /** Override the intake door's dependencies for isolated Discord seat-work tests. */
+  seatWorkDeps?: DiscordSeatWorkDeps;
 }
 
 /** Surface-unification v2 — minimal trigger-side event shape. Maps
@@ -204,6 +208,8 @@ export class DiscordBot {
   private readonly token: string;
   private readonly allowedUsers: Set<string>;
   private readonly guildTextChannels: Set<string>;
+  /** The bot's own user id (from READY) — EV12c lets an allowlisted @mention open any guild channel. */
+  private selfUserId: string | undefined;
   private readonly onMessage: DcMessageHandler;
   private readonly maxChars: number;
   private readonly log: (msg: string) => void;
@@ -216,6 +222,7 @@ export class DiscordBot {
   private readonly onReaction: ((event: DcReactionEvent) => void | Promise<void>) | null;
   /** Surface-unification v2 (FU-1) — workflow-runtime tap. */
   private readonly onTriggerTap: ((event: DcTriggerEvent) => void | Promise<void>) | null;
+  private readonly seatWorkDeps: DiscordSeatWorkDeps;
   private ws: WebSocket | null = null;
   private running = false;
   private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
@@ -239,6 +246,7 @@ export class DiscordBot {
     this.onInteraction = opts.onInteraction ?? null;
     this.onReaction = opts.onReaction ?? null;
     this.onTriggerTap = opts.onTriggerTap ?? null;
+    this.seatWorkDeps = opts.seatWorkDeps ?? {};
   }
 
   /** Send a raw payload on the gateway WebSocket. Voice adapter uses
@@ -604,6 +612,7 @@ export class DiscordBot {
             session_id?: string;
           };
           this.log(`READY — logged in as @${d.user?.username ?? '?'} (${d.user?.id ?? '?'})`);
+          if (d.user?.id) this.selfUserId = d.user.id;
           if (this.voiceTap?.onReady && d.session_id && d.user?.id) {
             try { this.voiceTap.onReady(d.session_id, d.user.id); }
             catch (err: any) { this.log(`voice tap onReady failed: ${err?.message ?? err}`); }
@@ -684,6 +693,20 @@ export class DiscordBot {
 
   // ── Message routing ────────────────────────────────────────
 
+  /** EV12c — true when this message @mentions the bot itself (mentions array or the raw `<@id>` token). */
+  private mentionsSelf(m: Record<string, unknown>, text: string): boolean {
+    const self = this.selfUserId;
+    if (!self) return false;
+    if (Array.isArray(m.mentions) && (m.mentions as Array<{ id?: unknown }>).some(u => String(u?.id) === self)) return true;
+    return text.includes(`<@${self}>`) || text.includes(`<@!${self}>`);
+  }
+
+  private stripSelfMention(text: string): string {
+    const self = this.selfUserId;
+    if (!self) return text;
+    return text.split(`<@!${self}>`).join('').split(`<@${self}>`).join('').replace(/\s+/g, ' ').trim();
+  }
+
   private async handleMessageCreate(m: Record<string, unknown>): Promise<void> {
     // Ignore bot's own messages (DM reply from our own send would
     // re-enter here).
@@ -692,19 +715,25 @@ export class DiscordBot {
 
     // DM-only v1 scope: guild_id is absent for DM channels.
     // Voice channel commands (`/voice-join`, `/voice-leave`,
-    // `/voice-status`) intentionally bypass DM-only — they need a
-    // guild context to operate. Everything else stays DM-routed so
-    // unrelated guild traffic doesn't reach the LLM path.
+    // `/voice-status`) and allowlisted, seat-addressed work bypass
+    // DM-only. All other guild traffic stays gated unless explicitly
+    // configured as a guild text channel.
     const isDm = !m.guild_id;
+    const rawText = typeof m.content === 'string' ? m.content : '';
+    const mentionsSelf = this.mentionsSelf(m, rawText);
     if (!isDm && !this.guildTextChannels.has(String(m.channel_id))) {
-      const trimmed = typeof m.content === 'string' ? m.content.trim() : '';
-      if (!/^\/voice-(join|leave|status)\b/.test(trimmed)) return;
+      if (!/^\/voice-(join|leave|status)\b/.test(rawText.trim())
+          && !(this.allowedUsers.has(author.id) && (parseSeatAddress(rawText) || mentionsSelf))) {
+        debug.log('discord.trigger', 'dropped', { reason: 'guild-not-chat', channelId: String(m.channel_id) });
+        return;
+      }
     }
 
     // Allowlist enforcement. An empty allowlist refuses everyone —
     // safer default than "open to the world" when the bot runs
     // with no user config.
     if (this.allowedUsers.size > 0 && !this.allowedUsers.has(author.id)) {
+      debug.log('discord.trigger', 'dropped', { reason: 'not-allowed', isDm });
       this.log(`discord: refusing unknown user ${author.id}`);
       try {
         await this.sendMessage(
@@ -738,7 +767,7 @@ export class DiscordBot {
       channelId: String(m.channel_id),
       userId: author.id,
       userName: author.username,
-      text: typeof m.content === 'string' ? m.content : '',
+      text: mentionsSelf ? this.stripSelfMention(rawText) : rawText,
       messageId: String(m.id),
       isDm,
       attachments,
@@ -790,6 +819,27 @@ export class DiscordBot {
       }
     }
 
+    // Addressed work is submitted only by configured owners; ordinary chat keeps its existing path.
+    if (this.allowedUsers.has(author.id) && parseSeatAddress(ctx.text)) {
+      const threadId = typeof m.thread_id === 'string' && m.thread_id ? m.thread_id : undefined;
+      const replyChannelId = threadId ?? ctx.channelId;
+      try {
+        const seatReply = await handleDiscordSeatWork(ctx.text, {
+          channelId: replyChannelId,
+          messageId: ctx.messageId,
+          ...(threadId ? { threadId } : {}),
+        }, this.seatWorkDeps);
+        if (seatReply !== null) {
+          await this.sendMessage(replyChannelId, seatReply);
+          return;
+        }
+      } catch (err: unknown) {
+        this.log(`discord seat work failed: ${err instanceof Error ? err.message : String(err)}`);
+        await this.sendMessage(replyChannelId, '좌석 요청을 접수하지 못했습니다. 잠시 후 다시 보내 주세요.');
+        return;
+      }
+    }
+
     // §C5 스트리밍 flip — streaming.discord ON 이면 옛 경로(placeholder+streamer+delivery) 억제,
     // 청크 fan-out sink 가 담당(handler chunkProducer 가 primarySurfaces=['discord']). 텔레그램 동형.
     const dcStreamingFlip = getUserConfig().sessionFabric?.streaming?.discord === true;