elanous 0.2.7 → 0.2.8

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/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/release-cli.ts

@@ -23,7 +23,7 @@ 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';
@@ -505,20 +505,21 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     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) => {