elanous 0.2.7 → 0.2.8

package/src/import/apply.ts

@@ -0,0 +1,128 @@
+// EN7 — `elanous import --apply` / `--undo`: run the EN4 plan. Skills register in place (EN9 `withConnectedSource`, `ref` default)
+// or as link/copy under the import folder; MCP joins `mcp.servers[]` switched off (EN8 `convertMcpEntry`); hooks, logins,
+// secrets and chat-bot tokens are only listed — never copied, never printed. Undo restores the config bytes and removes what apply made.
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { convertMcpEntry } from '../skills/connect-claude-plugin.js';
+import { withConnectedSource } from '../skills/connect.js';
+import type { SkillSource } from '../user-config.js';
+import type { ImportItem, ImportPlan } from './plan.js';
+
+export type ImportMode = 'ref' | 'link' | 'copy';
+export const IMPORT_MODES: readonly ImportMode[] = ['ref', 'link', 'copy'];
+
+export interface ImportManifest {
+  at: string;
+  mode: ImportMode;
+  configPath: string;
+  /** Config bytes before apply; null when there was no config file. */
+  backup: string | null;
+  /** Files and links apply created, removed on undo. */
+  created: string[];
+  applied: Array<{ id: string; how: string }>;
+  kept: Array<{ id: string; status: string; why: string }>;
+}
+
+export interface ApplyDeps {
+  home: string;
+  configPath: string;
+  /** Where links/copies, the manifest and the config backup live. */
+  importRoot: string;
+  sources: readonly SkillSource[];
+  rawMcpServers: ReadonlyArray<Record<string, unknown>>;
+  /** Persist the new skills sources and raw MCP server rows (the config writer). */
+  save: (sources: SkillSource[], rawServers: Array<Record<string, unknown>>) => void;
+  now?: () => Date;
+}
+
+const manifestPath = (importRoot: string) => join(importRoot, 'last-apply.json');
+const expand = (path: string, home: string) => (path.startsWith('~') ? join(home, path.slice(1)) : path);
+
+function readMcpSpec(item: ImportItem, home: string): unknown {
+  try {
+    const json = JSON.parse(readFileSync(expand(item.path, home), 'utf8')) as Record<string, unknown>;
+    const table = item.source === 'claude' ? json.mcpServers : (json.mcp as Record<string, unknown> | undefined)?.servers;
+    return (table as Record<string, unknown> | undefined)?.[item.name];
+  } catch { return undefined; }
+}
+
+export function readImportManifest(importRoot: string): ImportManifest | null {
+  try { return JSON.parse(readFileSync(manifestPath(importRoot), 'utf8')) as ImportManifest; } catch { return null; }
+}
+
+export function applyImport(plan: ImportPlan, opts: { mode?: ImportMode; pick?: readonly string[] }, deps: ApplyDeps): ImportManifest {
+  if (readImportManifest(deps.importRoot)) throw new Error('이미 적용한 가져오기가 있습니다 — 먼저 `elanous import --undo`');
+  const mode = opts.mode ?? 'ref';
+  const picked = opts.pick?.length ? new Set(opts.pick) : null;
+  const manifest: ImportManifest = {
+    at: (deps.now ?? (() => new Date()))().toISOString(), mode, configPath: deps.configPath,
+    backup: existsSync(deps.configPath) ? readFileSync(deps.configPath, 'utf8') : null, created: [], applied: [], kept: [],
+  };
+  let sources = [...deps.sources];
+  const rawServers = [...deps.rawMcpServers];
+  const keep = (item: ImportItem, why: string) => manifest.kept.push({ id: item.id, status: item.status, why });
+  mkdirSync(deps.importRoot, { recursive: true });
+
+  for (const item of plan.items) {
+    if (picked && !picked.has(item.id)) continue;
+    if (item.status === 'same') continue;
+    if (item.status !== 'new') {
+      keep(item, item.status === 'secret' || item.status === 'archived-only'
+        ? `보관만 — 옮기지도 켜지도 않는다${item.next ? ` · 따로: \`${item.next}\`` : ''}`
+        : item.status === 'conflict' ? '같은 이름 · 다른 내용 — 그대로 둔다' : '형식을 아직 옮기지 않는다');
+      continue;
+    }
+    if (item.kind === 'skill') {
+      const skillDir = expand(item.path, deps.home);
+      if (mode === 'ref') {
+        const root = join(skillDir, '..');
+        sources = withConnectedSource(sources, root, item.source);
+        manifest.applied.push({ id: item.id, how: `ref ${item.path}` });
+        continue;
+      }
+      const target = join(deps.importRoot, 'skills', item.source, item.name);
+      if (existsSync(target)) { keep(item, `이미 있다: ${target}`); continue; }
+      mkdirSync(join(target, '..'), { recursive: true });
+      if (mode === 'link') symlinkSync(skillDir, target, 'dir');
+      else cpSync(skillDir, target, { recursive: true, dereference: true });
+      manifest.created.push(target);
+      sources = withConnectedSource(sources, join(deps.importRoot, 'skills', item.source), `import:${item.source}`);
+      manifest.applied.push({ id: item.id, how: `${mode} ${item.path}` });
+      continue;
+    }
+    if (item.kind === 'mcp' && (item.source === 'claude' || item.source === 'openclaw')) {
+      const converted = convertMcpEntry(item.source, item.name, readMcpSpec(item, deps.home), '');
+      if ('skipped' in converted) { keep(item, converted.skipped); continue; }
+      if (rawServers.some((row) => row.id === item.name)) { keep(item, '같은 id 가 이미 있다'); continue; }
+      rawServers.push({ ...converted, id: item.name });
+      manifest.applied.push({ id: item.id, how: 'mcp 꺼진 채로' });
+      continue;
+    }
+    keep(item, '이 판에서는 옮기지 않는다');
+  }
+
+  if (manifest.applied.length) deps.save(sources, rawServers);
+  writeFileSync(manifestPath(deps.importRoot), `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+  return manifest;
+}
+
+/** Restore the config bytes and remove what apply created. Returns null when nothing was applied. */
+export function undoImport(importRoot: string): ImportManifest | null {
+  const manifest = readImportManifest(importRoot);
+  if (!manifest) return null;
+  if (manifest.backup === null) rmSync(manifest.configPath, { force: true });
+  else writeFileSync(manifest.configPath, manifest.backup);
+  for (const path of manifest.created) rmSync(path, { recursive: true, force: true });
+  rmSync(manifestPath(importRoot), { force: true });
+  return manifest;
+}
+
+export function formatApplied(m: ImportManifest): string {
+  const lines = [`가져왔습니다(${m.mode}) — ${m.applied.length}개 · 그대로 둔 것 ${m.kept.length}개. 되돌리려면: elanous import --undo`];
+  for (const a of m.applied.slice(0, 12)) lines.push(`  + ${a.id} — ${a.how}`);
+  if (m.applied.length > 12) lines.push(`  … 외 ${m.applied.length - 12}개`);
+  for (const k of m.kept.slice(0, 12)) lines.push(`  · ${k.id} [${k.status}] — ${k.why}`);
+  if (m.kept.length > 12) lines.push(`  … 외 ${m.kept.length - 12}개`);
+  if (m.applied.some((a) => a.how.startsWith('mcp'))) lines.push('MCP 서버는 꺼진 채로 넣었습니다. 믿을 수 있는 것만 켜 주세요(켠 뒤 데몬 재시작).');
+  return lines.join('\n');
+}

package/src/import/plan.ts

@@ -0,0 +1,197 @@
+// EN4 — `elanous import`: detect → plan on one screen, writes nothing (RESEARCH-entrances-for-codex-claude-openclaw-hermes-users §5a·§5b).
+// Each item names the existing sub-command that applies it (connect · nexus channel-bot import); `--apply` is EN7 (apply.ts).
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { findSkillFolders } from '../skills/connect.js';
+import { detectChannelImports, SOURCE_LABEL } from '../channel-import/detect.js';
+
+export type ImportSourceId = 'agents' | 'claude' | 'codex' | 'openclaw' | 'hermes';
+export type ImportItemKind = 'skill' | 'instructions' | 'mcp' | 'hooks' | 'credentials' | 'channel-bot';
+/** `same` already reachable/identical · `conflict` same name, different content · `archived-only` kept, never run · `secret` moved only on an explicit ask. */
+export type ImportItemStatus = 'new' | 'same' | 'conflict' | 'unsupported' | 'archived-only' | 'secret';
+
+export interface ImportSourceInfo { id: ImportSourceId; root: string; detected: boolean }
+export interface ImportItem {
+  /** `<source>:<kind>:<name>` — what `import --apply --pick` takes. */
+  id: string;
+  source: ImportSourceId;
+  kind: ImportItemKind;
+  name: string;
+  /** `~`-relative path the item was found in. */
+  path: string;
+  status: ImportItemStatus;
+  /** The existing command that applies this item; absent when nothing applies it yet. */
+  next?: string;
+  note?: string;
+}
+export interface ImportPlan { sources: ImportSourceInfo[]; items: ImportItem[] }
+
+export interface ImportPlanInput {
+  home: string;
+  /** `$CODEX_HOME` when set. */
+  codexHome?: string;
+  /** Skill directories elanous reads today (defaultSkillDirs). */
+  activeSkillDirs: readonly string[];
+  /** Ids of MCP servers already in elanous config. */
+  mcpServerIds: readonly string[];
+}
+
+export const IMPORT_STATUSES: readonly ImportItemStatus[] = ['new', 'same', 'conflict', 'unsupported', 'archived-only', 'secret'];
+
+function sourceRoots(input: ImportPlanInput): Record<ImportSourceId, string> {
+  const { home } = input;
+  const openclaw = [join(home, '.openclaw'), join(home, '.clawdbot'), join(home, '.moltbot')].find((p) => existsSync(p)) ?? join(home, '.openclaw');
+  return {
+    agents: join(home, '.agents'),
+    claude: join(home, '.claude'),
+    codex: input.codexHome || join(home, '.codex'),
+    openclaw,
+    hermes: join(home, '.hermes'),
+  };
+}
+
+const tilde = (path: string, home: string) => (path.startsWith(home) ? `~${path.slice(home.length)}` : path);
+const hash = (path: string) => { try { return createHash('sha256').update(readFileSync(path)).digest('hex'); } catch { return null; } };
+const readText = (path: string) => { try { return readFileSync(path, 'utf8'); } catch { return null; } };
+const readJson = (path: string): Record<string, unknown> | null => {
+  const raw = readText(path);
+  if (raw === null) return null;
+  try { const v = JSON.parse(raw) as unknown; return v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : null; } catch { return null; }
+};
+const keysOf = (value: unknown): string[] => (value && typeof value === 'object' && !Array.isArray(value) ? Object.keys(value as object) : []);
+const hasSecretFields = (spec: unknown): boolean => {
+  if (!spec || typeof spec !== 'object') return false;
+  const s = spec as Record<string, unknown>;
+  return keysOf(s.env).length > 0 || keysOf(s.headers).length > 0 || keysOf(s.http_headers).length > 0;
+};
+
+/** Skill folders of one root, each judged against what elanous already reads. */
+function skillItems(source: ImportSourceId, root: string, input: ImportPlanInput, next?: string): Array<Omit<ImportItem, 'id'>> {
+  const names = findSkillFolders(root);
+  const rootActive = input.activeSkillDirs.includes(root);
+  return names.map((name): Omit<ImportItem, 'id'> => {
+    const path = tilde(join(root, name), input.home);
+    if (rootActive) return { source, kind: 'skill', name, path, status: 'same', note: '이미 읽는 폴더' };
+    const mine = hash(join(root, name, 'SKILL.md'));
+    const twin = input.activeSkillDirs.map((dir) => join(dir, name, 'SKILL.md')).find((p) => existsSync(p));
+    if (twin) {
+      return hash(twin) === mine
+        ? { source, kind: 'skill', name, path, status: 'same', note: `같은 내용이 이미 있다: ${tilde(twin, input.home)}` }
+        : { source, kind: 'skill', name, path, status: 'conflict', note: `같은 이름 · 다른 내용: ${tilde(twin, input.home)}` };
+    }
+    return { source, kind: 'skill', name, path, status: 'new', ...(next ? { next } : { note: '적용 명령은 0.2.9 `import --apply`' }) };
+  });
+}
+
+function mcpItem(source: ImportSourceId, name: string, path: string, secret: boolean, input: ImportPlanInput): Omit<ImportItem, 'id'> {
+  if (secret) return { source, kind: 'mcp', name, path, status: 'secret', note: 'env·헤더 값이 있다 — 묻기 전까지 옮기지 않는다' };
+  if (input.mcpServerIds.includes(name)) return { source, kind: 'mcp', name, path, status: 'same', note: '같은 id 가 이미 있다' };
+  return { source, kind: 'mcp', name, path, status: 'new', note: '0.2.9 `import --apply` 가 꺼진 채로 넣는다' };
+}
+
+/** `[mcp_servers.<name>]` tables of a Codex config.toml; `env`/`headers` keys or sub-tables count as secret. */
+function codexMcp(raw: string): Array<{ name: string; secret: boolean }> {
+  const out = new Map<string, boolean>();
+  let current: string | null = null;
+  for (const line of raw.split(/\r?\n/)) {
+    const table = /^\s*\[([^\[\]]+)\]\s*(?:#.*)?$/.exec(line)?.[1]?.trim();
+    if (table !== undefined) {
+      const m = /^mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_-]+))(?:\.([A-Za-z_]+))?$/.exec(table);
+      current = m ? (m[1] ?? m[2]!) : null;
+      if (current) out.set(current, (out.get(current) ?? false) || ['env', 'headers', 'http_headers'].includes(m![3] ?? ''));
+      continue;
+    }
+    if (current && /^\s*(env|headers|http_headers)\s*=/.test(line)) out.set(current, true);
+  }
+  return [...out].map(([name, secret]) => ({ name, secret }));
+}
+
+/** Top-level keys under `mcp_servers:` in a Hermes config.yaml (two-space indent). */
+function hermesMcp(raw: string): string[] {
+  const block = /^mcp_servers:\s*\n((?:[ \t]+.*\n?|\s*\n)*)/m.exec(raw)?.[1] ?? '';
+  return [...block.matchAll(/^ {2}([A-Za-z0-9_.-]+):/gm)].map((m) => m[1]!);
+}
+
+export function planImport(input: ImportPlanInput): ImportPlan {
+  const roots = sourceRoots(input);
+  const sources = (Object.keys(roots) as ImportSourceId[]).map((id) => ({ id, root: tilde(roots[id], input.home), detected: existsSync(roots[id]) }));
+  const items: Array<Omit<ImportItem, 'id'>> = [];
+  const home = input.home;
+  const at = (p: string) => tilde(p, home);
+
+  if (existsSync(roots.agents)) {
+    items.push(...skillItems('agents', join(roots.agents, 'skills'), input));
+    if (existsSync(join(roots.agents, 'AGENTS.md'))) items.push({ source: 'agents', kind: 'instructions', name: 'AGENTS.md', path: at(join(roots.agents, 'AGENTS.md')), status: 'unsupported', note: '전역 지시 파일은 아직 싣지 않는다' });
+  }
+
+  if (existsSync(roots.claude)) {
+    items.push(...skillItems('claude', join(roots.claude, 'skills'), input, 'elanous connect claude'));
+    if (existsSync(join(roots.claude, 'CLAUDE.md'))) items.push({ source: 'claude', kind: 'instructions', name: 'CLAUDE.md', path: at(join(roots.claude, 'CLAUDE.md')), status: 'unsupported', note: '전역 지시 파일은 아직 싣지 않는다' });
+    const claudeJson = join(home, '.claude.json');
+    for (const [name, spec] of Object.entries((readJson(claudeJson)?.mcpServers ?? {}) as Record<string, unknown>)) items.push(mcpItem('claude', name, at(claudeJson), hasSecretFields(spec), input));
+    const settings = join(roots.claude, 'settings.json');
+    for (const event of keysOf(readJson(settings)?.hooks)) items.push({ source: 'claude', kind: 'hooks', name: event, path: at(settings), status: 'archived-only', note: '훅은 보관만 · 켜지 않는다' });
+    if (existsSync(join(roots.claude, '.credentials.json'))) items.push({ source: 'claude', kind: 'credentials', name: 'login', path: at(join(roots.claude, '.credentials.json')), status: 'secret', note: '로그인은 옮기지 않는다 · 엘라누스에서 따로 한 번' });
+  }
+
+  if (existsSync(roots.codex)) {
+    items.push(...skillItems('codex', join(roots.codex, 'skills'), input, 'elanous connect codex'));
+    if (existsSync(join(roots.codex, 'AGENTS.md'))) items.push({ source: 'codex', kind: 'instructions', name: 'AGENTS.md', path: at(join(roots.codex, 'AGENTS.md')), status: 'unsupported', note: '전역 지시 파일은 아직 싣지 않는다' });
+    const toml = join(roots.codex, 'config.toml');
+    const raw = readText(toml);
+    for (const server of raw ? codexMcp(raw) : []) items.push(mcpItem('codex', server.name, at(toml), server.secret, input));
+    if (existsSync(join(roots.codex, 'auth.json'))) items.push({ source: 'codex', kind: 'credentials', name: 'login', path: at(join(roots.codex, 'auth.json')), status: 'secret', note: '로그인은 옮기지 않는다 · 엘라누스에서 따로 한 번' });
+  }
+
+  if (existsSync(roots.openclaw)) {
+    items.push(...skillItems('openclaw', join(roots.openclaw, 'skills'), input));
+    const cfg = join(roots.openclaw, 'openclaw.json');
+    const servers = (readJson(cfg)?.mcp as Record<string, unknown> | undefined)?.servers;
+    for (const [name, spec] of Object.entries((servers && typeof servers === 'object' ? servers : {}) as Record<string, unknown>)) items.push(mcpItem('openclaw', name, at(cfg), hasSecretFields(spec), input));
+  }
+
+  if (existsSync(roots.hermes)) {
+    items.push(...skillItems('hermes', join(roots.hermes, 'skills'), input));
+    const yaml = join(roots.hermes, 'config.yaml');
+    const raw = readText(yaml);
+    for (const name of raw ? hermesMcp(raw) : []) items.push({ source: 'hermes', kind: 'mcp', name, path: at(yaml), status: 'unsupported', note: 'YAML 형식은 아직 변환하지 않는다' });
+  }
+
+  // EN13 — chat bots: token values stay masked; the existing import command stores them after the user agrees.
+  const bots = detectChannelImports(home);
+  for (const c of bots.candidates) {
+    const source: ImportSourceId | null = c.source === 'openclaw' ? 'openclaw' : c.source === 'hermes' ? 'hermes' : null;
+    if (!source) continue;
+    items.push({ source, kind: 'channel-bot', name: c.platform, path: c.file, status: 'secret', next: 'elanous nexus channel-bot import', note: `${SOURCE_LABEL[c.source]} 봇 토큰(가림)` });
+  }
+  for (const u of bots.unreadable) {
+    const source: ImportSourceId | null = u.file.includes('.hermes') ? 'hermes' : u.file.includes('.openclaw') || u.file.includes('.clawdbot') || u.file.includes('.moltbot') ? 'openclaw' : null;
+    if (source) items.push({ source, kind: 'channel-bot', name: 'bot', path: u.file, status: 'unsupported', note: u.reason });
+  }
+  return { sources, items: items.map((item) => ({ ...item, id: `${item.source}:${item.kind}:${item.name}` })) };
+}
+
+const KIND_LABEL: Record<ImportItemKind, string> = { skill: '스킬', instructions: '지시 파일', mcp: 'MCP', hooks: '훅', credentials: '로그인', 'channel-bot': '채팅 봇' };
+
+/** One screen: per source, counts by status, then the items that need a decision. */
+export function formatImportPlan(plan: ImportPlan): string {
+  const lines: string[] = ['가져오기 계획 — 아무것도 쓰지 않았습니다.', ''];
+  const detected = plan.sources.filter((s) => s.detected);
+  if (!detected.length) return [...lines, '쓰던 에이전트를 찾지 못했습니다(~/.agents · ~/.claude · ~/.codex · ~/.openclaw · ~/.hermes).'].join('\n');
+  for (const source of detected) {
+    const mine = plan.items.filter((i) => i.source === source.id);
+    const counts = IMPORT_STATUSES.map((s) => [s, mine.filter((i) => i.status === s).length] as const).filter(([, n]) => n > 0);
+    lines.push(`■ ${source.id} (${source.root}) — ${mine.length ? counts.map(([s, n]) => `${s} ${n}`).join(' · ') : '항목 없음'}`);
+    for (const kind of Object.keys(KIND_LABEL) as ImportItemKind[]) {
+      const group = mine.filter((i) => i.kind === kind && i.status !== 'same');
+      if (!group.length) continue;
+      const shown = group.slice(0, 6).map((i) => `${i.name}[${i.status}]`).join(', ');
+      lines.push(`  ${KIND_LABEL[kind]}: ${shown}${group.length > 6 ? ` 외 ${group.length - 6}개` : ''}`);
+    }
+  }
+  const nexts = [...new Set(plan.items.filter((i) => i.next && i.status !== 'same').map((i) => i.next!))];
+  lines.push('', '한 번에: `elanous import --apply` (스킬은 그 자리 등록 · MCP 는 꺼진 채로 · 비밀·훅은 보관만 · 되돌리기 `--undo`)');
+  lines.push(nexts.length ? `따로: ${nexts.map((n) => `\`${n}\``).join(' · ')}` : '따로 적용할 명령이 있는 항목은 없습니다.', '상태: new · same · conflict · unsupported · archived-only · secret — 자세히는 `elanous import --json`');
+  return lines.join('\n');
+}

package/src/index.ts

@@ -9,6 +9,9 @@ import { LOGS_SINCE_OPTION, registerLogsCommands } from './cli/logs-cli.js';
 import { registerDocsCommands } from './cli/docs-cli.js';
 import { registerA2ACommands } from './cli/a2a-cli.js';
 import { registerPluginCommands } from './cli/plugin-cli.js';
+import { registerConnectCommand, registerSkillsCommands } from './cli/skills-cli.js';
+import { registerImportCommand } from './cli/import-cli.js';
+import { registerPersonaCommands } from './cli/persona-cli.js';
 import { registerFleetCommands } from './cli/fleet-cli.js';
 import { readPipedStdin } from './cli/piped-stdin.js';
 import { writeStdoutJson } from './cli/stdout-json.js';
@@ -885,6 +888,10 @@ registerCardCommand(program);
 registerLaunchHeadCommands(program);
 registerA2ACommands(program);
 registerPluginCommands(program);
+registerSkillsCommands(program);
+registerConnectCommand(program);
+registerImportCommand(program);
+registerPersonaCommands(program);
 
 const marketCmd = program.command('market').description('Signed plugin marketplace');
 marketCmd.command('publish').description('Publish a local signed marketplace index and archives')
@@ -4177,6 +4184,9 @@ const selfOrchestrateCmd = selfCmd
       });
       process.env[HARNESS_RUN_ID_ENV] = runId;
       reportRunId = runId;
+      // HS1 — `harness stop <runId>` must find this process from the moment the run ID exists.
+      try { (await import('./self-dev/orchestrate.js')).writeRunPidRecord(runId); }
+      catch (error) { debug.log('self-dev.orchestrate', 'early-pid-failed', { runId, error: String(error) }, { level: 'warn' }); }
       const createdAt = prior?.createdAt ?? Date.now();
       const { bindOrchestrateRunLedger } = await import('./self-dev/self-orchestrate-runtime.js');
       const { checkpoint } = bindOrchestrateRunLedger({
@@ -4302,7 +4312,26 @@ const selfOrchestrateCmd = selfCmd
           grokApiKeyOptIn = getUserConfig().harness?.pod?.grokApiKeyOptIn === true;
           const credential = resolveGrokCredential();
           const { resolveCodexQuotaPolicy, codexPolicyAllowsCredits, codexPolicyAllowsFallback } = await import('./oauth/codex-quota-policy.js');
-          const quotaPolicy = resolveCodexQuotaPolicy(getUserConfig().llm).policy;
+          const resolvedQuota = resolveCodexQuotaPolicy(getUserConfig().llm);
+          const quotaPolicy = resolvedQuota.policy;
+          // POL1 — say which policy this launch uses and where it came from; warn when a test universe disagrees with production.
+          try {
+            const { effectiveInstanceRoot, prodInstanceRoot } = await import('./instance/resolve.js');
+            const { describeLaunchQuotaPolicy } = await import('./oauth/codex-quota-policy.js');
+            const root = effectiveInstanceRoot();
+            const kind = root === prodInstanceRoot() ? 'prod' as const : 'test' as const;
+            let production: ReturnType<typeof resolveCodexQuotaPolicy> | undefined;
+            if (kind === 'test') {
+              try {
+                const { readFileSync } = await import('node:fs');
+                const prodLlm = (JSON.parse(readFileSync(`${prodInstanceRoot()}/config.json`, 'utf8')) as { llm?: Record<string, unknown> }).llm;
+                production = resolveCodexQuotaPolicy(prodLlm);
+              } catch { /* no production config on this machine */ }
+            }
+            const described = describeLaunchQuotaPolicy({ current: resolvedQuota, universe: { kind, root }, ...(production ? { production } : {}) });
+            debug.log('self-implement.pod', 'quota-policy', { policy: resolvedQuota.policy, source: resolvedQuota.source, universe: kind, productionPolicy: production?.policy ?? null });
+            if (!opts.json) { ui.info(described.line); if (described.warning) ui.warn(described.warning); }
+          } catch { /* the line is advice; the launch goes on */ }
           const plan = planPodProvider({
             codexCandidates: inspectCodexRotation().candidates,
             // Per-account caps (대표 default:97) override the Pod default cap — without them default was dropped at 60%.
@@ -7258,16 +7287,31 @@ loginCmd
   .description('Sign in to OpenAI Codex via the ChatGPT device-code flow')
   .option('--replace-codex-cli-login', 'if the Codex CLI (~/.codex/auth.json) is signed in to a different account, replace it with this login')
   .action(async (opts: { replaceCodexCliLogin?: boolean }) => {
-    ui.header('OpenAI Codex — device-code sign-in');
+    // OB5d — say why there is no browser (ssh · no display) and what to do instead; otherwise try the browser first.
+    const { browserUnavailableReason } = await import('./oauth/browser-availability.js');
+    const noBrowser = browserUnavailableReason();
+    let browserState: Awaited<ReturnType<typeof import('./oauth/codex-browser-login.js')['loginWithCodexBrowser']>> | null = null;
+    if (!noBrowser) {
+      ui.header('OpenAI Codex — 브라우저 로그인');
+      console.log('  브라우저에서 로그인을 마치세요 — 끝나면 자동으로 이어집니다.');
+      try {
+        const { loginWithCodexBrowser } = await import('./oauth/codex-browser-login.js');
+        browserState = await loginWithCodexBrowser();
+      } catch {
+        console.log('  브라우저 로그인이 안 됐습니다 — 코드로 이어갑니다.');
+      }
+    }
+    if (!browserState) ui.header('OpenAI Codex — 코드로 로그인');
+    if (noBrowser) console.log(`  ${noBrowser}`);
     try {
-      const state = await loginWithCodex({
+      const state = browserState ?? await loginWithCodex({
         onProgress: (p) => {
           if (p.type === 'user_code' && p.userCode) {
             console.log('');
-            console.log(`  1) Open in any browser:   ${p.loginUrl}`);
-            console.log(`  2) Enter this code:       ${p.userCode}`);
+            console.log(`  1) 아무 브라우저에서 열기: ${p.loginUrl}`);
+            console.log(`  2) 코드 입력:             ${p.userCode}`);
             console.log('');
-            console.log('  Waiting for sign-in… (Ctrl+C to cancel)');
+            console.log('  로그인을 기다리는 중… (취소: Ctrl+C)');
           }
           if (p.type === 'polling' && p.pollAttempt === 1) {
             process.stdout.write('  .');
@@ -9797,6 +9841,23 @@ nexusChannelBotCmd
     process.exit(result.exitCode);
   });
 
+// EN13 — bring an existing Telegram/Discord bot over from OpenClaw · Hermes · the previous elanous (~/.monad).
+nexusChannelBotCmd
+  .command('import')
+  .description('Find Telegram/Discord bot settings you already use (OpenClaw, Hermes, previous elanous), preview them with the token masked, and store them after you agree.')
+  .option('--yes', 'Import without asking')
+  .action(async (opts: { yes?: boolean }) => {
+    const { runChannelImport } = await import('./channel-import/run.js');
+    const { createInterface } = await import('node:readline/promises');
+    const ask = process.stdin.isTTY ? async (question: string): Promise<boolean> => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try { const answer = (await rl.question(question)).trim(); return answer === '' || /^(y|yes|예|네)$/i.test(answer); }
+      finally { rl.close(); }
+    } : undefined;
+    const result = await runChannelImport({ yes: opts.yes, ...(ask ? { ask } : {}) });
+    process.exit(result.exitCode);
+  });
+
 // FU A6-real P5 (2026-05-11) — interactive Firecrawl setup.
 // Walks the user through CLI detection + API key entry + persist to
 // `registry.discovery.firecrawl.apiKey`. `--api-key <value>` skips
@@ -10461,6 +10522,14 @@ async function main(): Promise<void> {
   //   elanous --acp-server --transport=unix-socket --socket-path=/tmp/x.sock
   //   elanous --acp-server --transport=websocket --port=31415
   //   elanous --acp-server --transport=websocket --no-auth   # skip token check
+  if (rawArgs.includes('--acp-server') && rawArgs.includes('--login')) {
+    // EN10a — an ACP client's terminal auth re-launches `elanous --acp-server --login`: run the sign-in in that terminal and exit with its status.
+    const { ACP_LOGIN_SUBCOMMAND, currentLaunch } = await import('./acp/auth-methods.js');
+    const launch = currentLaunch();
+    const { spawnSync } = await import('node:child_process');
+    const run = spawnSync(launch.command, [...launch.args, ...ACP_LOGIN_SUBCOMMAND], { stdio: 'inherit' });
+    process.exit(run.status ?? 1);
+  }
   if (rawArgs.includes('--acp-server')) {
     const { bootAcpServer, parseAcpBootArgs } = await import('./boot/acp-server.js');
     const { createDaemonRuntime } = await import('./boot/daemon-runtime.js');
@@ -10751,12 +10820,18 @@ async function main(): Promise<void> {
  * 회귀 방어 = `src/cli-entry.test.ts`(실물 `bin/elanous.mjs` 를 spawn 한다).
  */
 export function runCli(): void {
-  main().catch((err) => {
+  main().catch(async (err) => {
     closeTui();
     if (isCliUserError(err)) {
       console.error(formatCliUserError(err));
       process.exit(1);
     }
+    // ER1 — a real crash is reported once (consented · scrubbed · never blocks more than the send timeout).
+    try {
+      const { reportError } = await import('./error-report/report.js');
+      const outcome = await reportError({ code: 'cli-crash', message: err instanceof Error ? `${err.name}: ${err.message}` : String(err), ...(err instanceof Error && err.stack ? { stack: err.stack } : {}), surface: 'cli' });
+      if (outcome.sent) console.error(`오류를 운영팀에 알렸습니다${outcome.reportId ? ` (보고 번호 ${outcome.reportId})` : ''}.`);
+    } catch { /* the crash itself is what matters */ }
     throw err;
   });
 }

package/src/input-core/text-entry.ts

@@ -40,15 +40,23 @@ export function keyEventToTextInsertion(
   return preservePrintableText(ev, name);
 }
 
+/** Hangul Compatibility Jamo (ㄱ…ㅣ · ㅋㅋ · ㅠㅠ). The key parser maps a lone jamo keystroke to the QWERTY key
+ *  on the same position so hotkeys work under the Korean IME — but as TEXT it must stay the jamo the person typed
+ *  (U1 · 2026-10-02: «ㅋㅋㅋ ㅠㅠ» came out as «zzz bb» in the chat input). */
+const COMPAT_JAMO = /^[\u3131-\u318E]$/;
+
 function preservePrintableText(ev: KeyEvent, name: string): string {
+  // The chat composer passes the TUI key (original bytes on `raw`); other composers pass a KeyEvent (`sequence`).
+  const sequence = ev.sequence ?? (ev as { raw?: string }).raw;
+  if (sequence && name.length === 1 && COMPAT_JAMO.test(sequence)) return sequence;
   if (
-    ev.sequence
-    && ev.sequence.length === 1
+    sequence
+    && sequence.length === 1
     && name.length === 1
-    && ev.sequence !== name
-    && ev.sequence.toLowerCase() === name.toLowerCase()
+    && sequence !== name
+    && sequence.toLowerCase() === name.toLowerCase()
   ) {
-    return ev.sequence;
+    return sequence;
   }
   if (name.length === 1) return ev.shift ? name.toUpperCase() : name;
   return name;

package/src/intake-plane/seat-answer.ts

@@ -0,0 +1,96 @@
+// EV12d — 계획기가 맞는 그래프를 못 고르면(«요청에 맞는 설치된 실행 그래프가 없습니다») «문서 요청 실패» 대신
+// 그 자리가 직접 답한다: 역할 파일(내부 문서 `<id>`) ⊕ 그 자리가 owner 인 체크리스트 칸 ⊕ 최근 요청 몇 줄을
+// 맥락으로 LLM 한 번 → 같은 채널 회신(본문). 맥락에 없는 것은 «모른다»고 답하게 한다(지어내지 않는다).
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { debug } from '../debug/log.js';
+import { ExecRequestStore, type ExecRequest } from '../exec-requests/store.js';
+import { devVersion, listChecklist, type ChecklistItem } from '../release-loop/checklist.js';
+import { resolveSeat } from '../seat-address/seat-address.js';
+
+const ROLE_CHARS = 6_000;
+
+/** Cut by code points, never inside a surrogate pair. A `.slice` through an emoji (🎉 · 🟢) leaves a lone surrogate and
+ *  the model API rejects the whole request («Codex API 400: Bad Request» · 10-02 07:4x — every «@CMO …» question failed). */
+function cut(text: string, max: number): string {
+  const chars = Array.from(text);
+  return chars.length > max ? chars.slice(0, max).join('') : text;
+}
+const ITEM_LIMIT = 25;
+const RECENT_LIMIT = 5;
+
+export interface SeatAnswerDeps {
+  readRole?: (seatId: string) => string | null;
+  ownedItems?: (seatId: string) => ChecklistItem[];
+  recentRequests?: () => ExecRequest[];
+  complete?: (prompt: string) => Promise<string>;
+}
+
+function defaultReadRole(seatId: string): string | null {
+  const path = fileURLToPath(new URL(`../../docs/roles/${seatId}.md`, import.meta.url));
+  return existsSync(path) ? readFileSync(path, 'utf8') : null;
+}
+
+function nextPatch(version: string): string | null {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return m ? `${m[1]}.${m[2]}.${Number(m[3]) + 1}` : null;
+}
+
+/** Items this seat owns in the dev version's checklist and the next one (where 10-28 work lives). */
+function defaultOwnedItems(seatId: string): ChecklistItem[] {
+  const versions = [devVersion().replace(/-.*$/, '')];
+  const next = nextPatch(versions[0]!);
+  if (next) versions.push(next);
+  const items: ChecklistItem[] = [];
+  for (const version of versions) {
+    try { items.push(...listChecklist(version).items.filter((item) => item.owner === seatId)); }
+    catch { /* a version without a checklist contributes nothing */ }
+  }
+  return items;
+}
+
+async function defaultComplete(prompt: string): Promise<string> {
+  const { streamLLM } = await import('../llm.js');
+  const { tierModel } = await import('../llm/model-defaults.js');
+  return streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('better') });
+}
+
+const STATUS_MARK: Record<string, string> = { green: '🟢', yellow: '🟡', red: '🔴', done: '✅' };
+
+export function seatAnswerPrompt(input: { title: string; seatId: string; question: string; role: string | null; items: ChecklistItem[]; recent: ExecRequest[] }): string {
+  const items = input.items.slice(0, ITEM_LIMIT)
+    .map((item) => `${STATUS_MARK[item.status] ?? item.status} ${item.id} ${cut(item.title, 140)}${item.evidence ? ` — 근거: ${cut(item.evidence, 160)}` : ''}`)
+    .join('\n') || '(담당 칸 없음)';
+  const recent = input.recent.slice(0, RECENT_LIMIT)
+    .map((request) => `${request.createdAt.slice(0, 16)} ${request.status} · ${cut(request.text.replace(/\s+/g, ' '), 120)}`)
+    .join('\n') || '(최근 요청 없음)';
+  return [
+    `너는 엘라누스 팀의 ${input.title}(${input.seatId}) 자리다. 아래 «역할 문서 · 담당 칸 · 최근 요청»만 근거로 질문에 답한다.`,
+    '규칙: 한국어 존댓말 · 12줄 이내 · 맥락에 없는 사실·수치·일정은 지어내지 말고 «모른다/확인 필요»라고 쓴다 · 담당 칸을 인용할 땐 칸 ID 를 붙인다 · 내부 파일 경로·토큰·계정은 쓰지 않는다.',
+    `\n## 역할 문서\n${cut(input.role ?? '(역할 문서 없음)', ROLE_CHARS)}`,
+    `\n## 담당 칸(체크리스트 owner=${input.seatId})\n${items}`,
+    `\n## 최근 자리 요청\n${recent}`,
+    `\n## 질문\n${input.question}`,
+  ].join('\n');
+}
+
+/** The seat's own answer, or null when the seat is unknown or the model gave nothing usable. */
+export async function answerAsSeat(seatAddress: string, question: string, deps: SeatAnswerDeps = {}): Promise<{ title: string; text: string } | null> {
+  const seat = resolveSeat(seatAddress);
+  if (!seat?.title) return null;
+  const role = (deps.readRole ?? defaultReadRole)(seat.id);
+  const items = (deps.ownedItems ?? defaultOwnedItems)(seat.id);
+  const recent = (deps.recentRequests ?? (() => new ExecRequestStore().list()))();
+  const raw = await (deps.complete ?? defaultComplete)(seatAnswerPrompt({ title: seat.title, seatId: seat.id, question, role, items, recent }));
+  const text = raw.trim();
+  debug.log('intake.seat-doc', 'seat-answer', { seat: seat.id, roleFile: role !== null, items: items.length, recent: Math.min(recent.length, RECENT_LIMIT), chars: text.length });
+  return text ? { title: seat.title, text: cut(text, 3_500) } : null;
+}
+
+/** «No installed graph fits» — the planner's own failure wording, so the seat should answer instead. */
+export function isNoGraphFailure(result: { status: string; summary?: string; seats?: Array<{ graphId: string; reason?: string }> } | null): boolean {
+  if (!result || result.status !== 'failed' || !result.seats?.length) return false;
+  if (!result.seats.every((seat) => !seat.graphId)) return false;
+  const NO_GRAPH = /설치된 실행 그래프가 없습니다/;
+  return NO_GRAPH.test(result.summary ?? '') || result.seats.some((seat) => NO_GRAPH.test(seat.reason ?? ''));
+}