elanous 0.2.7 → 0.2.9

package/src/chat/index.ts

@@ -431,7 +431,14 @@ export interface SlashCommand {
 
 // Default commands available in the input
 export const SLASH_COMMANDS: SlashCommand[] = [
-  { name: 'directive', aliases: [], description: 'Record a directive as a Linear issue' },
+  { name: 'help',  aliases: ['?'],         description: '명령과 키 보기' },
+  { name: 'resume',    aliases: [],             description: '지난 대화 이어 가기 · /resume <id 앞자리>' },
+  { name: 'model',     aliases: ['m'],           description: '모델 바꾸기 — /model <codex|terra|sol|luna|opus|sonnet|grok> (list + current when no arg). OpenAI 는 Codex(Responses API)만. effort 는 /reasoning.', subcommands: ['codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
+  { name: 'clear', aliases: ['cls'],       description: '대화 기록 지우기' },
+  { name: 'status', aliases: ['st'], description: '지금 상태 — 모델 · 연결 · 계정' },
+  { name: 'remaining', aliases: [], description: '계정별 남은 사용량' },
+  { name: 'setup', aliases: [], description: '상세 설정 — /setup · /setup reset(다음 실행 때 마법사 다시)', subcommands: ['help', 'reset'] },
+  { name: 'quit',  aliases: ['q', 'exit'], description: '나가기' },
   { name: 'run-skill', aliases: ['rs', 'run'], description: 'Execute a skill via its SKILL.md prompt' },
   { name: 'ad', aliases: [], description: 'Create an advertising plan from a URL, brief, or attached image' },
   // B4 — craft rulebook verdict, same resolution as `elanous repo design-check`
@@ -440,10 +447,8 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'design',    aliases: ['design-check'], description: 'Design rulebooks this repository declares · /design [--declared] · /design pick [number|id] to choose a design direction', subcommands: ['--declared', 'pick'] },
   { name: 'provider',  aliases: ['p'],          description: 'LLM providers — /provider (list) · next (cycle, also Alt+M / pill click) · use <name> · pick (visual picker) · reset', subcommands: ['next', 'use', 'pick', 'picker', 'menu', 'reset', 'list'] },
   { name: 'reasoning', aliases: ['r', 'think'],  description: 'Reasoning level (codex effort + summary, anthropic extended-thinking budget) — /reasoning [off|low|medium|high|xhigh] (cycle when no arg · xhigh 는 모델 상한이 xhigh 이상일 때만 wire 에 실린다, 아니면 high 로 깎인다)', subcommands: ['off', 'low', 'medium', 'high', 'xhigh'] },
-  { name: 'model',     aliases: ['m'],           description: 'Switch active model — /model <codex|terra|sol|luna|opus|sonnet|grok> (list + current when no arg). OpenAI 는 Codex(Responses API)만. effort 는 /reasoning.', subcommands: ['codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
   { name: 'local',     aliases: ['ll'],         description: 'Local OpenAI-compatible LLM — ping / models / test / use', subcommands: ['ping', 'models', 'test', 'use', 'status'] },
   { name: 'session',   aliases: ['sess'],       description: 'Session resume — list / load / sync / new (handoff from mobile)', subcommands: ['list', 'load', 'sync', 'new'] },
-  { name: 'resume',    aliases: [],             description: 'Pick a past session, or load one by id prefix · /resume <id-prefix>' },
   { name: 'fork',      aliases: [],             description: 'Copy this session into a new one' },
   { name: 'rewind',    aliases: [],             description: 'Rewind — 과거 user 턴 픽커로 되감기 (원본 보존 · 새 세션 분기 · /rewind <n> 숏컷)' },
   // TUI 부활 C-a (2026-07-12): autopilot 미션 TUI 표면 — CLI 동등 단일 창구 소비.
@@ -454,12 +459,8 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'sync',  aliases: ['s'],         description: 'Enter sync mode' },
   { name: 'plugin', aliases: ['plugins'], description: 'Manage plugins', subcommands: ['list', 'activate', 'deactivate', 'reload'] },
   { name: 'widget', aliases: ['widgets'], description: 'Manage widgets', subcommands: ['list', 'reload', 'instances'] },
-  { name: 'clear', aliases: ['cls'],       description: 'Clear chat log' },
   { name: 'log',   aliases: [],             description: 'Chat Log controls — size / clear / filter / search / freeze / solo / turn / fold / help', subcommands: ['size', 'clear', 'filter', 'search', 'freeze', 'solo', 'turn', 'fold', 'help'] },
-  { name: 'help',  aliases: ['?'],         description: 'Show help overlay' },
-  { name: 'setup', aliases: [], description: 'Onboarding wizard guide — /setup (anchor) · /setup reset (re-run wizard on next boot)', subcommands: ['help', 'reset'] },
   { name: 'memory', aliases: ['mem'], description: 'Memory ops — list / show / search / add / delete (see `elanous memory --help`)', subcommands: ['list', 'show', 'search', 'add', 'delete', 'index'] },
-  { name: 'status', aliases: ['st'], description: 'Print the claude-code-style status pills (working dir + git + model)' },
   { name: 'export', aliases: [], description: 'Export this conversation transcript to a markdown file — /export [path] (default ~/temp/elanous-transcript-<stamp>.md)' },
   { name: 'delta', aliases: ['diffs'], description: 'Source delta browser — open the latest turn-scoped file diff popup', subcommands: ['open', 'help'] },
   { name: 'theme', aliases: [], description: 'Theme controls — list / switch / use / reset / preview / export', subcommands: ['list', 'switch', 'use', 'reset', 'preview', 'export'] },
@@ -486,7 +487,6 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'acp',    aliases: [], description: 'ACP chat — stream claude-code / codex / gemini replies into the chat pane (not a VW spawn). /acp codex points at the canonical codex app-server path; /acp cas is a synonym.', subcommands: ['claude', 'codex', 'gemini', 'cas', 'cancel', 'status', 'drop'] },
   { name: 'conv', aliases: [], description: 'Conversation widget/popup host — /conv list · /conv open <session-id> · /conv layout <cascade|tile|stack> · /conv focus <next|prev>.', subcommands: ['list', 'ls', 'open', 'layout', 'focus'] },
   { name: 'handoff', aliases: [], description: 'H5 P3 cross-agent context handoff: /handoff <from_session_id> <to_brand> [--channels r,p,m] [--prompt "prefix"]. Takes source session snapshot (filtered by channels if observer present) and launches target via adapter registry. Brands: codex · claude · claude-code · gemini · elanous.' },
-  { name: 'remaining', aliases: [], description: 'What each account has left' },
   { name: 'agent-room', aliases: [], description: 'H6 P4 VW agent-room — /agent-room <N> <brands...> · /agent-room list · /agent-room close <id> · N ∈ {2,3,4} · brands: codex/claude/gemini/elanous/auto/lll:<m>', subcommands: ['list', 'close', 'preset', 'help'] },
   { name: 'showroom', aliases: ['sr'], description: 'Showroom v2 multi-LLM lane composer — /showroom (default 2-pane) · /showroom <lane1> <lane2> [<lane3> [<lane4>]] · lane = role:provider[:transport] · roles plan/build/exec/review/reflect · pair with /lane and /relay for cross-lane handoffs.', subcommands: ['help'] },
   { name: 'reply',   aliases: [], description: 'H6 P5 AgentReply — /reply <target-session-id> <message...> · send message to a live session, capture the response · flags: --from · --channels r,m · --idle-ms · --timeout-ms', subcommands: ['help'] },
@@ -503,7 +503,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'qc',      aliases: [],          description: 'Quick-control — arm one-shot control mode; next message runs as control, then auto-return to chat.' },
   { 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: 'quit',  aliases: ['q', 'exit'], description: 'Exit application' },
+  { name: 'directive', aliases: [], description: '(운영) 지시를 Linear 이슈로 기록' },
 ];
 
 /** Every user-visible slash spelling, normalized for runtime-catalog comparison. */

package/src/cli/config-test-sync.ts

@@ -41,6 +41,9 @@ export const TEST_SYNC_AUX_FILES: readonly string[] = [
   'llm-fallback.json', // 모델 폴백 체인
   'auth.json',         // oauth 자격 (LLM provider)
   'identity.json',     // self identity — 무해·자기인식 일관
+  // POL1 (10-01): the LLM policy (credit use · pace · grants). Without it a tree's test universe resolved «fallback»
+  // while production said «credits», and every harness run from a work tree went to grok.
+  'policy/llm.yaml',
 ];
 
 /** 의도적 제외 (복사 금지 — 이유 명시. 목록 변경 시 반드시 사유와 함께). */
@@ -201,6 +204,7 @@ export function syncTestConfig(testDir: string, srcDir: string = prodConfigDir()
     //   목록 뒤의 `auth.json`(codex 로그인)이 복사되지 않아 격리 우주의 자식이 codex 를 못 썼다.
     //   ⇒ 이미 같은 바이트면 건너뛴다(멱등) — 다르면 종전처럼 복사한다(실패는 그대로 드러난다).
     if (existsSync(to) && readFileSync(from).equals(readFileSync(to))) { chmodSync(to, 0o600); skippedIdentical.push(f); continue; }
+    mkdirSync(dirname(to), { recursive: true });
     copyFileSync(from, to);
     chmodSync(to, 0o600);
     copied.push(f);

package/src/cli/decisions-cli.ts

@@ -9,6 +9,12 @@ function date(raw?: string): string | undefined {
   if (!Number.isFinite(parsed.getTime())) throw new Error(`invalid since: ${raw}`);
   return parsed.toISOString();
 }
+/** `+6h` → now + 6 hours; otherwise a UTC ISO timestamp (validated by the ledger). */
+function dueAt(raw: string): string {
+  const hours = /^\+(\d+(?:\.\d+)?)h$/.exec(raw.trim());
+  if (hours) return new Date(Date.now() + Number(hours[1]) * 3600000).toISOString();
+  return raw.trim();
+}
 const kst = (at: string) => new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul', dateStyle: 'short', timeStyle: 'medium' }).format(new Date(at)) + ' KST';
 const version = (e: DecisionEntry['version']) => e ? `released=${e.released ?? '-'} · dev=${e.dev ?? '-'}${e.codename ? ` «${e.codename}»` : ''}` : '판 미상';
 function agent(o?: string): string {
@@ -30,6 +36,7 @@ export function formatDecisionDetail(e: DecisionEntry): string {
     '선택지 | 결과', ...(e.options.length ? e.options.map(o => `${o.key}: ${o.label} | ${o.consequence}`) : ['원문에 선택지 없음 · 확인 필요']),
     'skipped' in e.recommendation ? `권고 생략: ${e.recommendation.reason}` : `권고: ${e.recommendation.option} — ${e.recommendation.why}`,
     `올림: ${e.raisedAt ? kst(e.raisedAt) : '시각 미상'} · ${e.raisedBy.agent} · ${version(e.version)}`,
+    ...(e.dueAt ? [`기한: ${kst(e.dueAt)}`] : []),
     ...(e.importedAt ? [`가져옴: ${kst(e.importedAt)}`] : []),
     ...(e.status === 'decided' ? [`결정: ${e.decidedAt ? kst(e.decidedAt) : '시각 미상'} · ${e.decidedBy?.kind === 'auto' ? `AUTO ${e.decidedBy.agent} (${e.decidedBy.delegation})` : e.decidedBy?.kind === 'human' ? 'human' : '주체 미상'} · ${e.choice ?? '선택 키 미상'} · ${e.versionAtDecision ? version(e.versionAtDecision) : '결정 당시 판 미상'}`,
       ...(e.note ? [`메모: ${e.note}`] : [])] : []),
@@ -48,14 +55,17 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])
     .option('--recommend <key>').option('--why <text>').option('--skip-recommend <reason>')
     .option('--track <track>').option('--agent <agent>').option('--session <id>')
-    .option('--ref <url>', '참조 (반복)', repeat, [] as string[]).option('--json')
-    .action((o: { title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; ref: string[]; json?: boolean }) => fail(() => {
+    .option('--ref <url>', '참조 (반복)', repeat, [] as string[])
+    .option('--due <when>', '기한 — UTC ISO(2026-10-04T09:00:00Z) 또는 +Nh(지금부터 N시간) · 기한 2시간 전 텔레그램·디스코드로 다시 알린다')
+    .option('--json')
+    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; ref: string[]; json?: boolean }) => fail(() => {
       if (o.skipRecommend !== undefined && (o.recommend !== undefined || o.why !== undefined)) throw new Error('choose recommendation or skip, not both');
       if (o.skipRecommend === undefined && (!o.recommend || !o.why)) throw new Error('--recommend and --why required, or --skip-recommend <reason>');
       const options: DecisionOption[] = o.option.map(parseOption);
       const entry = new DecisionLedger(config).raise({ title: o.title, category: o.category, scqa: { s: o.s, c: o.c, ...(o.q ? { q: o.q } : {}), ...(o.a ? { a: o.a } : {}) }, options,
         recommendation: o.skipRecommend !== undefined ? { skipped: true, reason: o.skipRecommend } : { option: o.recommend!, why: o.why! },
-        raisedBy: { agent: agent(o.agent), ...(o.track ? { track: o.track } : {}), ...(o.session ? { session: o.session } : {}) }, ...(o.ref.length ? { refs: o.ref } : {}) });
+        raisedBy: { agent: agent(o.agent), ...(o.track ? { track: o.track } : {}), ...(o.session ? { session: o.session } : {}) }, ...(o.ref.length ? { refs: o.ref } : {}),
+        ...(o.due ? { dueAt: dueAt(o.due) } : {}) });
       emit(entry, o.json, `올림: ${formatDecisionRow(entry)}`);
     }));
   root.command('list').description('결정 목록 (기본 열린 것)')

package/src/cli/doctor-bundle.ts

@@ -0,0 +1,128 @@
+import { spawnSync } from 'node:child_process';
+import { closeSync, existsSync, lstatSync, mkdtempSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir, platform, arch } from 'node:os';
+import { join, resolve, sep } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { resolveCurrentInstance } from '../instance/current.js';
+import { LogStore, logsDbPath, type LogStoreRow } from '../mss/logging/log-store.js';
+import { cliVersion, codeRevision, packageVersion } from '../version/code-revision.js';
+import { runDoctor, defaultReadInstallPrefix, type DoctorOptions, type DoctorReport } from './doctor-cli.js';
+
+const REDACTED = '<redacted>';
+
+/** Recursively redact named secrets and secret-shaped text before serialization. */
+export function redactForBundle(value: unknown, home: string = homedir(), redactNamedFields: boolean = true): unknown {
+  if (typeof value === 'string') {
+    let text = value;
+    if (home && home !== sep) {
+      // Match the home as a path component, including JSON-escaped slashes.
+      const escaped = home.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      text = text.replace(new RegExp(`${escaped}(?=[/\\\\]|$)`, 'g'), '~');
+    }
+    // By kind, not by the last example found: headers that carry credentials, credentials inside URLs,
+    // known token shapes, and any `name=value` / `"name": "value"` whose name says it is a credential.
+    return text
+      .replace(/\b((?:Proxy-)?Authorization\s*:\s*)[^\r\n"']+/gi, `$1${REDACTED}`)
+      .replace(/\b((?:Set-)?Cookie\s*:\s*)[^\r\n"']+/gi, `$1${REDACTED}`)
+      .replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@"'<>]+@/gi, `$1${REDACTED}@`)
+      .replace(/(["']?(?:[\w-]*(?:token|key|secret|password|passwd|pwd|cookie|session|credential|auth))["']?\s*[:=]\s*["']?)[^\s"',}&]+/gi, `$1${REDACTED}`)
+      .replace(/\b(Bearer|Basic|Token)\s+[A-Za-z0-9._~+/=-]{8,}/g, `$1 ${REDACTED}`)
+      .replace(/\b(?:sk-[A-Za-z0-9_-]+|gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+|glpat-[A-Za-z0-9_-]+|xox[a-z]-[A-Za-z0-9-]+|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{35})\b/g, REDACTED)
+      .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, REDACTED);
+  }
+  if (Array.isArray(value)) return value.map((entry) => redactForBundle(entry, home, redactNamedFields));
+  if (value && typeof value === 'object') {
+    const result: Record<string, unknown> = Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+      const safeKey = redactForBundle(key, home) as string;
+      result[safeKey] = redactNamedFields && /(?:token|key|secret|password|passwd|pwd|authorization|cookie|session|credential|auth)/i.test(key)
+        ? REDACTED : redactForBundle(entry, home, redactNamedFields);
+    }
+    return result;
+  }
+  return value;
+}
+
+export interface DoctorBundleOptions {
+  outDir: string;
+  now?: Date;
+  /** Read-only doctor seams for isolated tests. */
+  doctorOptions?: DoctorOptions;
+  home?: string;
+  configDir?: string;
+  logDbPath?: string;
+  doctorReport?: DoctorReport;
+}
+
+export interface DoctorBundleResult { path: string; files: string[]; bytes: number }
+
+/** Bundle only generated, redacted entries. Never put an unprocessed source file into tar. */
+export function buildDoctorBundle({ outDir, now = new Date(), doctorOptions = {}, home = homedir(), configDir = getElanousConfigDir(), logDbPath = logsDbPath(), doctorReport }: DoctorBundleOptions): DoctorBundleResult {
+  const instant = now.toISOString();
+  const stamp = instant.replace(/[-:]/g, '').slice(0, 15).replace('T', '-');
+  mkdirSync(outDir, { recursive: true, mode: 0o700 });
+  const destination = resolve(outDir, `elanous-diagnostics-${stamp}.tar.gz`);
+  if (existsSync(destination)) throw new Error('diagnostics archive already exists');
+  const work = mkdtempSync(join(outDir, '.elanous-diagnostics-'));
+  const files: string[] = [];
+  const put = (name: string, data: unknown): void => {
+    writeFileSync(join(work, name), JSON.stringify(redactForBundle(data, home, name === 'config.redacted.json' || name === 'onboarding.json'), null, 2) + '\n', { mode: 0o600 });
+    files.push(name);
+  };
+  try {
+    const report = doctorReport ?? runDoctor(doctorOptions);
+    const universe = resolveCurrentInstance({ cwd: () => process.cwd() });
+    const packageRoot = resolve(import.meta.dir, '../..');
+    const installPrefix = doctorOptions.readInstallPrefix?.() ?? defaultReadInstallPrefix(packageRoot, existsSync);
+    let logs: LogStoreRow[] = [];
+    let logStatus: 'ok' | 'no-store' = 'no-store';
+    if (existsSync(logDbPath)) {
+      try {
+        const store = LogStore.openReadOnly(logDbPath);
+        try {
+          logs = store.query({ sinceMs: now.getTime() - 86_400_000, untilMs: now.getTime(), limit: 500 });
+          logStatus = 'ok';
+        } finally { store.close(); }
+      } catch { /* Unreadable store: export no unverified log bytes. */ }
+    }
+    put('summary.json', {
+      version: packageVersion(), sha: codeRevision() ?? 'unknown', cliVersion: cliVersion(),
+      os: platform(), arch: arch(), node: process.version, bun: typeof Bun === 'undefined' ? null : Bun.version,
+      installPath: installPrefix ?? packageRoot,
+      universe: { kind: universe.kind, root: universe.root }, createdAt: instant, logs: logStatus,
+    });
+    put('doctor.json', report);
+    let config: unknown = {};
+    const configPath = doctorOptions.configPath ?? join(configDir, 'config.json');
+    try {
+      if (lstatSync(configPath).isFile()) config = JSON.parse(readFileSync(configPath, 'utf8'));
+    } catch { config = { status: 'unavailable' }; }
+    put('config.redacted.json', config);
+    put('credentials.json', report.credentials.map(({ name, resolved, source }) => ({ name, present: resolved, source })));
+    writeFileSync(join(work, 'logs-recent.jsonl'), logs.map((row) => {
+      const entry = row as { data: string | null };
+      let data = entry.data;
+      if (data) {
+        try { data = JSON.stringify(redactForBundle(JSON.parse(data), home)); }
+        catch { /* Non-JSON log bodies are redacted as plain text below. */ }
+      }
+      return JSON.stringify(redactForBundle({ ...row, data }, home, false));
+    }).join('\n') + (logs.length ? '\n' : ''), { mode: 0o600 });
+    files.push('logs-recent.jsonl');
+    const onboardingPath = join(configDir, 'onboarding.json');
+    try {
+      if (lstatSync(onboardingPath).isFile()) put('onboarding.json', JSON.parse(readFileSync(onboardingPath, 'utf8')));
+    } catch { /* An absent or unreadable optional record is not exported. */ }
+    const archiveFd = openSync(destination, 'wx', 0o600);
+    let tarSucceeded = false;
+    try {
+      const tar = spawnSync('tar', ['-czf', '-', '-C', work, ...files], { stdio: ['ignore', archiveFd, 'pipe'], timeout: 30_000 });
+      tarSucceeded = !tar.error && tar.status === 0;
+    } finally {
+      closeSync(archiveFd);
+      if (!tarSucceeded) rmSync(destination, { force: true });
+    }
+    if (!tarSucceeded) throw new Error('could not create diagnostics archive');
+    return { path: destination, files, bytes: statSync(destination).size };
+  } finally { rmSync(work, { recursive: true, force: true }); }
+}

package/src/cli/doctor-cli.ts

@@ -35,6 +35,9 @@ import { gitInstallPlan } from './git-install-plan.js';
 import { detectDistroFamily, parseOsRelease } from './doctor-distro.js';
 import { checkPythonEnv } from './python-cli.js';
 import { describeModes, formatModeLine, type DoctorMode } from './doctor-modes.js';
+import { formatDoctorLocalLlm, probeDoctorLocalLlm, type DoctorLocalLlm } from './doctor-local-llm.js';
+import type { LlmInventory } from '../llm/local-manager/types.js';
+import { buildDoctorBundle } from './doctor-bundle.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -102,6 +105,8 @@ export interface DoctorReport {
   capabilitySummary?: DoctorCapabilitySummary;
   /** Read-only configuration and chat-use status. Present on a successful report. */
   modes?: DoctorMode[];
+  /** Local LLM inventory; CLI probes separately so synchronous credential reports stay read-only and unchanged. */
+  localLlm?: DoctorLocalLlm;
   /** F1 readiness. Present on a successful report. Absent when the report itself failed. */
   readiness?: ReadinessReport;
   reason?: string;
@@ -186,6 +191,8 @@ export interface DoctorCliDeps extends DoctorOptions, Pick<DoctorFixDeps, 'home'
   resolveAdviceProvider?: (config: UserConfig) => { provider: string; model: string; auth: string };
   confirmAdvice?: (message: string) => Promise<boolean>;
   adviceInteractive?: boolean;
+  /** Local-manager inventory seam; default calls getInventory(). */
+  localLlmInventory?: () => Promise<LlmInventory>;
 }
 
 const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
@@ -1141,6 +1148,7 @@ export function formatDoctorReport(report: DoctorReport, options: { credentials?
     ...(report.externalCommandsCatalogUnavailable ? [`External commands catalog unavailable: ${report.externalCommandsCatalogReason ?? 'catalog/external-commands.yaml is unavailable.'}`] : []),
     ...formatCapabilitySummary(capabilitySummary),
     ...(report.modes ? ['모드:', ...report.modes.map((row) => `  ${formatModeLine(row)}`)] : []),
+    ...(report.localLlm ? formatDoctorLocalLlm(report.localLlm) : []),
   ].join('\n');
 }
 
@@ -1208,12 +1216,37 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
     .description('Reports whether credentials resolve and where each resolution comes from')
     .option('--json', 'structured output')
     .option('--credentials', 'show per-credential details in human-readable output')
+    .option('--bundle', 'write a redacted diagnostics archive for support')
+    .option('--out <dir>', 'output directory for --bundle')
     .option('--fix', 'show repairs; git installation asks on a TTY (other repairs require --yes)')
     .option('--advise', 'ask the configured LLM to rank catalog repairs (read-only advice)')
     .option('--yes', 'apply planned doctor repairs (requires --fix)')
     .option('--sudo', 'also run the planned sudo install lines — only where `sudo -n true` works (requires --fix --yes)')
     .option('--restart', 'restart the nexus service when it runs a different version than this installed copy, then verify it (requires --fix --yes · interrupts bots, terminals and running turns)')
-    .action(async (opts: { json?: boolean; credentials?: boolean; fix?: boolean; advise?: boolean; yes?: boolean; sudo?: boolean; restart?: boolean }) => {
+    .action(async (opts: { json?: boolean; credentials?: boolean; bundle?: boolean; out?: string; fix?: boolean; advise?: boolean; yes?: boolean; sudo?: boolean; restart?: boolean }) => {
+      if (opts.bundle) {
+        if (opts.fix || opts.advise || opts.yes || opts.sudo || opts.restart) {
+          err.error('--bundle cannot be combined with repair or advice options');
+          setExitCode(1);
+          return;
+        }
+        try {
+          // Same report as `doctor --json`, local LLM section included, so support sees what the user saw.
+          const doctorReport = runDoctor(deps);
+          if (doctorReport.ok) doctorReport.localLlm = await probeDoctorLocalLlm(deps.localLlmInventory);
+          const result = buildDoctorBundle({ outDir: opts.out ?? process.cwd(), doctorOptions: deps, doctorReport });
+          out.log(opts.json ? JSON.stringify(result) : [`Diagnostics: ${result.path} (${result.bytes} bytes)`, 'Contents:', ...result.files.map((file) => `  ${file}`)].join('\n'));
+        } catch {
+          err.error('Could not create diagnostics archive.');
+          setExitCode(1);
+        }
+        return;
+      }
+      if (opts.out !== undefined) {
+        err.error('--out requires --bundle');
+        setExitCode(1);
+        return;
+      }
       if (opts.yes && !opts.fix) {
         err.error('--yes requires --fix');
         setExitCode(1);
@@ -1240,6 +1273,7 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
         setExitCode(1);
         return;
       }
+      report.localLlm = await probeDoctorLocalLlm(deps.localLlmInventory);
       if (!opts.fix && !opts.advise) {
         out.log(opts.json ? JSON.stringify(report, null, 2) : formatDoctorReport(report, { credentials: opts.credentials }));
         if (report.requiredMissing?.length) setExitCode(1);
@@ -1358,6 +1392,7 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
         : undefined;
       // PATH cannot change in this process; re-probe readiness rather than treating a saved block as PATH=ok.
       const currentReport = results || gitInstall?.ran ? runDoctor(deps) : report;
+      if (currentReport.ok) currentReport.localLlm = report.localLlm;
       if (gitInstall?.ran && gitInstall.ok && currentReport.requiredMissing?.includes('git')) {
         gitInstall.detail = 'git init 성공 · 현재 doctor PATH 에서 git 을 찾지 못했습니다. 새 셸에서 다시 확인하세요.';
       }

package/src/cli/doctor-local-llm.ts

@@ -0,0 +1,95 @@
+import { debug } from '../debug/log.js';
+import { probeDocker } from '../llm/local-manager/docker-probe.js';
+import { probeLmstudio } from '../llm/local-manager/lmstudio-probe.js';
+import { probeMlx } from '../llm/local-manager/mlx-probe.js';
+import { listNodes } from '../llm/local-manager/node-registry.js';
+import { probeOllama } from '../llm/local-manager/ollama-probe.js';
+import type { LlmInventory, LlmModel, LlmNode, LlmRuntime } from '../llm/local-manager/types.js';
+
+export interface DoctorLocalLlm {
+  nodes: { kind: 'ollama' | 'lmstudio' | 'mlx' | 'docker'; baseUrl: string; reachable: boolean; models: string[] }[];
+  timedOut: boolean;
+  /** Inventory lookup failed; absence of servers was not established. */
+  failed?: boolean;
+}
+
+const kinds = ['ollama', 'lmstudio', 'mlx', 'docker'] as const;
+type Kind = (typeof kinds)[number];
+
+const baseUrlFields: Record<Kind, 'ollamaBaseUrl' | 'lmstudioBaseUrl' | 'mlxBaseUrl' | 'dockerBaseUrl'> = {
+  ollama: 'ollamaBaseUrl', lmstudio: 'lmstudioBaseUrl', mlx: 'mlxBaseUrl', docker: 'dockerBaseUrl',
+};
+
+type Probe = (node: { id: string; isLocal: boolean }, deps: { timeoutMs?: number }) => Promise<{ reachable: boolean; models: readonly LlmModel[]; warnings: readonly string[] }>;
+
+/** Doctor shows only this machine, so it probes only the local node — the full inventory also probes every remote
+ *  fleet node over ssh and took ~7 s cold, past the 3 s cap («시간 초과» with LM Studio running · 10-01). */
+export async function localInventory(deps: {
+  nodes?: () => readonly LlmNode[];
+  probes?: Record<'lmstudio' | 'ollama' | 'mlx' | 'docker', Probe>;
+  now?: () => number;
+} = {}): Promise<LlmInventory> {
+  const probes = deps.probes ?? { lmstudio: probeLmstudio, ollama: probeOllama, mlx: probeMlx, docker: probeDocker } as Record<'lmstudio' | 'ollama' | 'mlx' | 'docker', Probe>;
+  const read = deps.nodes ?? listNodes;
+  const nodes: LlmNode[] = [];
+  const models: LlmModel[] = [];
+  const warnings: string[] = [];
+  for (const node of read().filter((n) => n.isLocal)) {
+    const seed = { id: node.id, isLocal: true };
+    const order = ['lmstudio', 'ollama', 'mlx', 'docker'] as const;
+    const results = await Promise.all(order.map((kind) => probes[kind](seed, { timeoutMs: 2500 })));
+    const runtimes: LlmRuntime[] = order.filter((_, i) => results[i]!.reachable);
+    for (const [i, r] of results.entries()) { models.push(...r.models); for (const w of r.warnings) warnings.push(`${node.id}:${order[i]}:${w}`); }
+    // Probes record base URLs in the registry on success — read the node back for them.
+    const fresh = read().find((n) => n.id === node.id) ?? node;
+    nodes.push({ ...fresh, reachable: runtimes.length > 0, runtimes });
+  }
+  return { nodes, models, at: (deps.now ?? Date.now)(), cached: false, warnings };
+}
+
+export async function probeDoctorLocalLlm(inventory: () => Promise<LlmInventory> = () => localInventory(), timeoutMs = 3000): Promise<DoctorLocalLlm> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let result: DoctorLocalLlm;
+  try {
+    const snapshot = await Promise.race([
+      Promise.resolve().then(inventory),
+      new Promise<null>((resolve) => { timer = setTimeout(() => resolve(null), timeoutMs); }),
+    ]);
+    result = snapshot === null
+      ? { nodes: [], timedOut: true }
+      : {
+        nodes: snapshot.nodes.filter((node) => node.isLocal).flatMap((node) => kinds.flatMap((kind) => {
+          const baseUrl = node[baseUrlFields[kind]];
+          if (!node.runtimes.includes(kind) && !baseUrl) return [];
+          return [{
+            kind,
+            baseUrl: baseUrl ?? '',
+            reachable: node.reachable === true && node.runtimes.includes(kind),
+            models: snapshot.models.filter((model) => model.nodeId === node.id && model.runtime === kind).map((model) => model.id),
+          }];
+        })),
+        timedOut: false,
+      };
+  } catch {
+    result = { nodes: [], timedOut: false, failed: true };
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+  }
+  debug.log('doctor.local-llm', 'probed', {
+    nodes: result.nodes.length,
+    reachable: result.nodes.filter((node) => node.reachable).length,
+    models: result.nodes.reduce((total, node) => total + node.models.length, 0),
+    timedOut: result.timedOut,
+  });
+  return result;
+}
+
+export function formatDoctorLocalLlm(result: DoctorLocalLlm): string[] {
+  if (result.timedOut) return ['Local LLM:', '  시간 초과'];
+  if (result.failed) return ['Local LLM:', '  로컬 LLM 인벤토리를 조회하지 못했다'];
+  if (result.nodes.length === 0) return ['Local LLM:', '  로컬 LLM 서버를 찾지 못했다 — Ollama(:11434) · LM Studio(:1234) 를 띄우면 여기 보인다'];
+  return [
+    'Local LLM:',
+    ...result.nodes.map((node) => `  ${node.kind} · ${node.baseUrl} · ${node.reachable ? '닿음' : '안 닿음'} · 모델 ${node.models.length}개${node.models.length ? ` · ${node.models.slice(0, 5).join(', ')}` : ''}`),
+  ];
+}

package/src/cli/import-cli.ts

@@ -0,0 +1,60 @@
+// EN4 — `elanous import`: one read-only plan over the agents you already use. Applying stays with the sub-commands each item names.
+import type { Command } from 'commander';
+import { homedir } from 'node:os';
+import { debug } from '../debug/log.js';
+import { formatImportPlan, planImport, type ImportPlan } from '../import/plan.js';
+import { applyImport, formatApplied, IMPORT_MODES, undoImport, type ImportMode } from '../import/apply.js';
+import { dirname, join } from 'node:path';
+
+export async function buildImportPlan(home = homedir()): Promise<ImportPlan> {
+  const { defaultSkillDirs, getUserConfig } = await import('../user-config.js');
+  const cfg = getUserConfig();
+  const plan = planImport({
+    home,
+    ...(process.env.CODEX_HOME ? { codexHome: process.env.CODEX_HOME } : {}),
+    activeSkillDirs: defaultSkillDirs(cfg),
+    mcpServerIds: (cfg.mcp?.servers ?? []).map((server) => server.id),
+  });
+  for (const item of plan.items) debug.log('import.plan', 'item', { source: item.source, kind: item.kind, status: item.status });
+  debug.log('import.plan', 'planned', { sources: plan.sources.filter((s) => s.detected).map((s) => s.id), items: plan.items.length });
+  return plan;
+}
+
+export function registerImportCommand(program: Command): void {
+  program.command('import')
+    .description('Show what elanous can bring over from Claude Code, Codex, ~/.agents, OpenClaw and Hermes — a plan first; `--apply` registers skills in place and adds MCP switched off, `--undo` puts everything back')
+    .option('--json', 'Print the plan (or the apply result) as JSON')
+    .option('--apply', 'Apply the plan: skills in place (ref) or as link/copy · MCP switched off · secrets and hooks only listed')
+    .option('--mode <mode>', `How skills come over: ${IMPORT_MODES.join('|')} (default ref — nothing copied)`)
+    .option('--pick <ids>', 'Only these item ids (comma-separated, see --json)')
+    .option('--undo', 'Undo the last --apply: restore the config bytes and remove links/copies')
+    .action(async (opts: { json?: boolean; apply?: boolean; mode?: string; pick?: string; undo?: boolean }) => {
+      const { userConfigPath } = await import('../user-config.js');
+      const importRoot = join(dirname(userConfigPath()), 'import');
+      if (opts.undo) {
+        const undone = undoImport(importRoot);
+        const { resetSkillIndex } = await import('../skills/index.js');
+        resetSkillIndex();
+        debug.log('import.apply', 'undone', { found: undone !== null, created: undone?.created.length ?? 0 });
+        if (opts.json) console.log(JSON.stringify({ undone: undone !== null }));
+        else console.log(undone ? `되돌렸습니다 — 설정을 ${undone.at} 이전으로 돌리고, 만든 것 ${undone.created.length}개를 지웠습니다.` : '되돌릴 가져오기가 없습니다.');
+        return;
+      }
+      const plan = await buildImportPlan();
+      if (!opts.apply) { console.log(opts.json ? JSON.stringify(plan, null, 2) : formatImportPlan(plan)); return; }
+      if (opts.mode !== undefined && !IMPORT_MODES.includes(opts.mode as ImportMode)) throw new Error(`--mode 는 ${IMPORT_MODES.join('|')} 중 하나다(받은 값: ${opts.mode})`);
+      const { getUserConfig, saveUserConfig } = await import('../user-config.js');
+      const cfg = getUserConfig();
+      const rawMcp = (cfg.raw.mcp && typeof cfg.raw.mcp === 'object' && !Array.isArray(cfg.raw.mcp) ? cfg.raw.mcp : {}) as Record<string, unknown>;
+      const manifest = applyImport(plan, { ...(opts.mode ? { mode: opts.mode as ImportMode } : {}), ...(opts.pick ? { pick: opts.pick.split(',').map((id) => id.trim()).filter(Boolean) } : {}) }, {
+        home: homedir(), configPath: userConfigPath(), importRoot,
+        sources: cfg.skills.sources ?? [],
+        rawMcpServers: (Array.isArray(rawMcp.servers) ? rawMcp.servers : []) as Array<Record<string, unknown>>,
+        save: (sources, servers) => saveUserConfig({ ...cfg, raw: { ...cfg.raw, mcp: { ...rawMcp, servers } }, skills: { ...cfg.skills, sources } }),
+      });
+      const { resetSkillIndex } = await import('../skills/index.js');
+      resetSkillIndex();
+      debug.log('import.apply', 'applied', { mode: manifest.mode, applied: manifest.applied.length, kept: manifest.kept.length, created: manifest.created.length });
+      console.log(opts.json ? JSON.stringify({ mode: manifest.mode, applied: manifest.applied, kept: manifest.kept, created: manifest.created.length }, null, 2) : formatApplied(manifest));
+    });
+}

package/src/cli/mcp-login.ts

@@ -12,6 +12,7 @@ import {
 } from '../mcp/mcp-oauth.js';
 import { parseWwwAuthenticate } from '../mcp/client.js';
 import { debug } from '../debug/log.js';
+import { browserUnavailableReason } from '../oauth/browser-availability.js';
 
 const CALLBACK_PATH = '/oauth/callback';
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -31,6 +32,8 @@ export interface McpLoginOpts {
   readConfigFn?: () => { mcp?: { servers: McpServerSpec[] } };
   fetch?: McpOAuthFetch;
   openBrowser?: (url: string) => Promise<void>;
+  browserEnv?: NodeJS.ProcessEnv;
+  browserPlatform?: NodeJS.Platform;
   createListener?: (handler: (req: IncomingMessage, res: ServerResponse) => void) => Server;
   /** 발견한 issuer/tokenEndpoint 를 config 에 되쓰는 자리. 테스트 심. */
   persistDiscoveryFn?: (input: PersistDiscoveryInput) => PersistDiscoveryResult;
@@ -91,10 +94,16 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
     void callbackPromise.catch(() => undefined);
     out.log(`Open this URL to authorize '${opts.serverId}':`);
     out.log(authorization.request.url);
-    try {
-      await (opts.openBrowser ?? openDefaultBrowser)(authorization.request.url);
-    } catch {
-      out.error('Could not open the default browser; open the URL above manually.');
+    const why = browserUnavailableReason(opts.browserEnv ?? process.env, opts.browserPlatform ?? process.platform);
+    if (why) {
+      out.log(why);
+      debug.log('browser.open', 'skipped', { reason: why.includes('ssh') ? 'ssh' : 'no-display' });
+    } else {
+      try {
+        await (opts.openBrowser ?? openDefaultBrowser)(authorization.request.url);
+      } catch {
+        out.error('Could not open the default browser; open the URL above manually.');
+      }
     }
     const callback = await callbackPromise;
     await exchangeAuthorizationCode(authorization.metadata, authorization.request, callback, {

package/src/cli/op-proxy-sync.ts

@@ -0,0 +1,83 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ACP_TOKEN_FILE } from '../auth/token-store.js';
+import { debug } from '../debug/log.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { userConfigPath } from '../user-config.js';
+
+export interface OpProxyConfig {
+  host: string;
+  bearerFile: string;
+  restart: string;
+}
+
+/** Read the optional, unnormalized nexus setting from the same config file as the CLI. */
+export function readOpProxyConfig(path = userConfigPath()): OpProxyConfig | undefined {
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8')) as { nexus?: { opProxy?: OpProxyConfig } };
+    return raw?.nexus?.opProxy;
+  } catch {
+    return undefined;
+  }
+}
+
+type SshExecutor = (argv: string[], input: string) => { status: number | null; error?: Error };
+
+export function finishOpProxyRotation(
+  proxy: OpProxyConfig | undefined,
+  token: string,
+  opts: { sync: boolean; ssh?: SshExecutor; tokenFile?: string; out?: (line: string) => void },
+): boolean | undefined {
+  if (!proxy) return undefined;
+  if (!opts.sync) {
+    (opts.out ?? console.log)('op 프록시 토큰도 갈아야 합니다 — `elanous token rotate --sync-op-proxy`');
+    return undefined;
+  }
+  return syncOpProxyToken(proxy, token, opts);
+}
+
+const executeSsh: SshExecutor = (argv, input) => {
+  const result = spawnSync('ssh', argv, { input, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 30_000 });
+  return { status: result.status, ...(result.error ? { error: result.error } : {}) };
+};
+
+const shellQuote = (value: string): string => `'${value.replaceAll("'", "'\\''")}'`;
+
+/** Never interpolate the token in a command, diagnostic, or log. Only SSH stdin carries it. */
+export function syncOpProxyToken(
+  proxy: OpProxyConfig | undefined,
+  token: string,
+  opts: { ssh?: SshExecutor; tokenFile?: string; out?: (line: string) => void } = {},
+): boolean | undefined {
+  if (!proxy) return undefined;
+  const out = opts.out ?? console.log;
+  const host = typeof proxy.host === 'string' ? proxy.host : '';
+  const file = typeof proxy.bearerFile === 'string' ? proxy.bearerFile : '';
+  const service = typeof proxy.restart === 'string' ? proxy.restart : '';
+  const valid = /^[\w][\w.-]*$/.test(host) && file.startsWith('/') && !/[\r\n\0]/.test(file)
+    && /^[\w@][\w@.-]*$/.test(service) && !/[\r\n\0]/.test(opts.tokenFile ?? '');
+  const remote = `sudo install -m 600 /dev/stdin ${shellQuote(file)} && sudo systemctl restart ${shellQuote(service)}`;
+  const manual = valid
+    ? `token=$(head -n 1 < ${shellQuote(opts.tokenFile ?? join(getElanousConfigDir(), ACP_TOKEN_FILE))}) && [ -n "$token" ] && printf 'ELANOUS_OP_BEARER=%s\\n' "$token" | ssh ${shellQuote(host)} ${shellQuote(remote)}`
+    : 'nexus.opProxy 의 host, bearerFile, restart 를 확인한 뒤 bearer 파일을 갱신하고 서비스를 재시작하세요';
+  let reason = '';
+  if (!valid) {
+    reason = 'nexus.opProxy 설정 오류';
+  } else {
+    try {
+      const result = (opts.ssh ?? executeSsh)([host, remote], `ELANOUS_OP_BEARER=${token}\n`);
+      if (result.status === 0 && !result.error) {
+        debug.log('auth.op-proxy-sync', 'synced', { host, reason: 'ok' });
+        out(`op 프록시 토큰을 바꿨습니다(${host})`);
+        return true;
+      }
+      reason = result.error ? 'ssh 실행 실패' : `ssh 종료 코드 ${result.status ?? '미상'}`;
+    } catch {
+      reason = 'ssh 실행 실패';
+    }
+  }
+  debug.log('auth.op-proxy-sync', 'failed', { host, reason });
+  out(`op 프록시 토큰 동기화 실패(${host}): ${reason} — 직접: ${manual}`);
+  return false;
+}