elanous 0.2.6 → 0.2.8

package/src/onboarding.ts

@@ -25,13 +25,16 @@
 // back-fill merge — so tests don't need to stub config paths either.
 
 import { existsSync, statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { isHeadlessEnv, spawnCodexLogin, type CodexLoginResult } from './acp/codex-auth.js';
 import { getRunContext, type RunContext } from './agent/run-context.js';
 import * as readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import {
   type UserConfig, type LLMProviderName, type SkillSetName,
   saveUserConfig, markOnboardingComplete, buildUserConfig,
-  skillSetDir, SKILL_SET_NAMES, userConfigPath, urlRoutingDefaults, devRequestRoutingDefaults,
+  skillSetDir, SKILL_SET_NAMES, userConfigPath, urlRoutingDefaults, devRequestRoutingDefaults, defaultSkillDirs, resolveSkillSources,
 } from './user-config.js';
 import {
   GROK_MODEL, OPENAI_MODEL, ANTHROPIC_MODEL, LOCAL_LLM_MODEL, GEMINI_MODEL,
@@ -40,7 +43,9 @@ import {
 import { CODEX_DEFAULT_MODEL } from './llm.js';
 import { suggestSetupModel } from './model-tier/index.js';
 import { loginWithCodex, CODEX_DEVICE_LOGIN_URL } from './oauth/codex.js';
+import { loginWithCodexBrowser } from './oauth/codex-browser-login.js';
 import { loadTokens } from './oauth/store.js';
+import { browserUnavailableReason } from './oauth/browser-availability.js';
 import { TelegramBot } from './telegram.js';
 import { DiscordBot } from './discord.js';
 import { pickCodexAuthMode, pickCodexModel } from './codex/setup.js';
@@ -54,6 +59,11 @@ import type {
 import { showStepOr, chooseFrom } from './onboarding/io-extended.js';
 import { askWithHelp } from './onboarding/wire-helpers.js';
 import { stepTransition } from './onboarding/transition.js';
+import { unattendedSetupHint } from './onboarding/entry-hints.js';
+import { continueHereLines } from './onboarding/continue-here.js';
+import type { NexusShowResult } from './cli/nexus-show.js';
+import type { TailscaleProbe } from './nexus/onboarding/tailscale-probe.js';
+import type { IssuedTempToken } from './auth/temp-tokens.js';
 import {
   askValidated,
   validateIntList,
@@ -151,6 +161,8 @@ export interface WizardIO {
    *  and `ask` otherwise. */
   askSecret?(prompt: string, field?: string): Promise<string>;
   print(text: string): void;
+  /** Synthetic, unattended IO (never issue or display a connection token). */
+  nonInteractive?: boolean;
   /** Called once after a successful config save. */
   complete?(): void;
   close(): void;
@@ -325,6 +337,108 @@ export interface LocalProbeDeps {
 
 export interface GrokOnboardingDeps {
   resolveCredential?: () => GrokCredential | null;
+  /** Subscription detection for step 1 (OB1) — tests inject; default = `detectProviders`. */
+  detectProviders?: () => Promise<import('./llm/provider-detect.js').DetectedProvider[]>;
+  /** OB1 — does the codex CLI already hold a usable login (~/.codex/auth.json)? Tests inject. */
+  hasCodexCliLogin?: () => boolean;
+  loadCodexTokens?: typeof loadTokens;
+  /** Browser-first OAuth test seams. Defaults use the local environment. */
+  codexEnv?: NodeJS.ProcessEnv;
+  isHeadless?: (env: NodeJS.ProcessEnv) => boolean;
+  loginWithCodexBrowser?: typeof loginWithCodexBrowser;
+  spawnCodexLogin?: (opts: { deviceAuth: false; codexPath: string }) => Promise<CodexLoginResult>;
+  loginWithCodex?: typeof loginWithCodex;
+  /** Execute local browser/clipboard commands without a shell. Returns false when unavailable. */
+  runAuthCommand?: (command: string, args: string[], input?: string) => boolean;
+  authPlatform?: NodeJS.Platform;
+  /** OSC52 fallback, when clipboard commands are unavailable. */
+  writeAuthTerminal?: (data: string) => boolean;
+}
+
+function pathCodexBinary(env: NodeJS.ProcessEnv): string | null {
+  const binary = process.platform === 'win32' ? 'codex.exe' : 'codex';
+  for (const dir of (env.PATH ?? '').split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, binary);
+    try { if (existsSync(candidate) && statSync(candidate).isFile()) return candidate; }
+    catch { /* skip inaccessible PATH entries */ }
+  }
+  return null;
+}
+
+function runAuthCommand(command: string, args: string[], input?: string): boolean {
+  try {
+    const result = spawnSync(command, args, {
+      input,
+      stdio: [input === undefined ? 'ignore' : 'pipe', 'ignore', 'ignore'],
+      timeout: 3_000,
+    });
+    return result.status === 0 && !result.error;
+  } catch { return false; }
+}
+
+function assistCodexDeviceLogin(
+  io: WizardIO,
+  url: string,
+  code: string,
+  deps: GrokOnboardingDeps,
+): void {
+  const env = deps.codexEnv ?? process.env;
+  const platform = deps.authPlatform ?? process.platform;
+  const execute = deps.runAuthCommand ?? runAuthCommand;
+  const local = !(deps.isHeadless ?? isHeadlessEnv)(env);
+  const unavailable = browserUnavailableReason(env, platform);
+  if (unavailable) {
+    io.print(`  ${unavailable}`);
+    debug.log('browser.open', 'skipped', { reason: unavailable.includes('ssh') ? 'ssh' : 'no-display' });
+  } else if (local) {
+    try {
+      if (platform === 'darwin') execute('open', [url]);
+      else if (platform === 'linux' || platform === 'freebsd' || platform === 'openbsd') execute('xdg-open', [url]);
+    } catch { /* browser is optional; URL remains visible */ }
+  }
+  let copied = false;
+  for (const [command, args] of platform === 'darwin'
+    ? [['pbcopy', []]] as Array<[string, string[]]>
+    : platform === 'linux' || platform === 'freebsd' || platform === 'openbsd'
+      ? [['wl-copy', []], ['xclip', ['-selection', 'clipboard']]] as Array<[string, string[]]>
+      : []) {
+    try { if (execute(command, args, code)) { copied = true; break; } }
+    catch { /* try the next clipboard */ }
+  }
+  if (!copied) {
+    try {
+      const write = deps.writeAuthTerminal ?? ((data: string) => {
+        if (!output.isTTY) return false;
+        output.write(data);
+        return true;
+      });
+      copied = write(`\x1b]52;c;${Buffer.from(code).toString('base64')}\x07`);
+    } catch { /* terminals without OSC52 still show the code */ }
+  }
+  if (copied) io.print('  코드를 복사했습니다.');
+  if (local) notifyDeviceCode(code, copied, platform, execute);
+}
+
+/** OB5c — on a desktop, raise an OS notification with the code so the person can paste it without
+ *  hunting for the terminal. Missing notifier (or headless) is skipped silently; the code never goes to logs. */
+function notifyDeviceCode(
+  code: string,
+  copied: boolean,
+  platform: NodeJS.Platform,
+  execute: (command: string, args: string[], input?: string) => boolean,
+): void {
+  const message = copied ? `인증 코드 ${code} — 클립보드에 복사됨 · 붙여넣기만` : `인증 코드 ${code}`;
+  let notified = false;
+  try {
+    if (platform === 'darwin') {
+      const quoted = (s: string) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+      notified = execute('osascript', ['-e', `display notification ${quoted(message)} with title "Elanous"`]);
+    } else if (platform === 'linux' || platform === 'freebsd' || platform === 'openbsd') {
+      notified = execute('notify-send', ['Elanous', message]);
+    }
+  } catch { /* no notifier — the code stays on screen */ }
+  debug.log('onboarding.codex', 'device-code-notify', { platform, copied, notified });
 }
 
 /** Default probe — calls into the local-LLM manager's quad-probe
@@ -425,7 +539,18 @@ async function askLLM(
     excerpt: getMessages().setupStepLLMExcerpt,
     severity: 'required',
   });
-  const currentIdx = PROVIDER_CHOICES.findIndex(c => c.key === current.provider);
+  // OB1 (10-01): show subscriptions the machine already has and preselect one — the old default was the env-only
+  // «Auto-detect», so a ChatGPT/Codex or Grok subscriber pressing Enter got a setup that found nothing.
+  let detected: import('./llm/provider-detect.js').DetectedProvider[] = [];
+  try {
+    const detect = grokDeps.detectProviders ?? (async () => (await import('./llm/provider-detect.js')).detectProviders());
+    detected = await detect();
+  } catch { /* detection is advisory — the list still works */ }
+  const { subscriptionHint } = await import('./onboarding/subscription-hint.js');
+  const hint = subscriptionHint(detected);
+  for (const found of hint.found) io.print(found.line);
+  const configured = current.provider && current.provider !== 'auto' ? current.provider : undefined;
+  const currentIdx = PROVIDER_CHOICES.findIndex(c => c.key === (configured ?? hint.preferred));
   const providerOptions: ChoiceOption<ProviderChoice | WizardBackValue>[] =
     PROVIDER_CHOICES.map((c, i) => ({
       key: String(i + 1),
@@ -448,7 +573,7 @@ async function askLLM(
     && (grokDeps.resolveCredential ?? resolveGrokCredential)()?.kind === 'subscription';
   if (grokSubscription) io.print('  Found grok subscription (~/.grok/auth.json)');
   if (choice.key === 'auto') {
-    io.print('  → auto mode: will detect from XAI/OPENAI/ANTHROPIC/LOCAL_LLM env vars.');
+    io.print('  → auto mode: uses a subscription login it finds (ChatGPT/Codex ~/.codex · Grok ~/.grok) first, then XAI/OPENAI/ANTHROPIC/LOCAL_LLM env vars.');
     return out;
   }
 
@@ -456,26 +581,60 @@ async function askLLM(
   // Keeps onboarding and `elanous codex setup` in sync — one picker, one
   // curated model catalog, one source of truth for provider defaults.
   if (choice.key === 'openai-codex') {
-    const mode = await pickCodexAuthMode(io);
+    const mode = await pickCodexAuthMode(io, {
+      ...(grokDeps.hasCodexCliLogin ? { hasCodexCliLogin: grokDeps.hasCodexCliLogin } : {}),
+      ...(grokDeps.loadCodexTokens ? { loadTokens: grokDeps.loadCodexTokens } : {}),
+    });
     if (mode === 'oauth') {
-      io.print('  Launching device-code flow…');
-      try {
-        await loginWithCodex({
-          onProgress: (p) => {
-            if (p.type === 'user_code') {
-              io.print('');
-              io.print(`    1) Open in any browser: ${p.loginUrl}`);
-              io.print(`    2) Enter code:          ${p.userCode}`);
-              io.print('');
-              io.print('  Waiting for sign-in…');
-            }
-            if (p.type === 'saved') io.print('  Signed in. Tokens saved.');
-          },
-        });
-      } catch (err: any) {
-        io.print(`  ! OAuth failed: ${err?.message ?? err}`);
-        io.print(`    Navigate to ${CODEX_DEVICE_LOGIN_URL} manually,`);
-        io.print(`    or re-run \`elanous login openai-codex\` / \`elanous codex setup\` later.`);
+      const env = grokDeps.codexEnv ?? process.env;
+      let signedIn = false;
+      const why = browserUnavailableReason(env, grokDeps.authPlatform ?? process.platform);
+      if (why) {
+        io.print(`  ${why}`);
+        debug.log('browser.open', 'skipped', { reason: why.includes('ssh') ? 'ssh' : 'no-display' });
+      }
+      if (!why && !(grokDeps.isHeadless ?? isHeadlessEnv)(env)) {
+        // Full-screen IO retains print() messages across redraws. Keep this
+        // waiting hint transient so it cannot reappear on the device-code screen.
+        if (io.showStep) output.write('  브라우저에서 로그인을 마치세요 — 끝나면 자동으로 이어집니다.\n');
+        else io.print('  브라우저에서 로그인을 마치세요 — 끝나면 자동으로 이어집니다.');
+        try {
+          await (grokDeps.loginWithCodexBrowser ?? loginWithCodexBrowser)();
+          signedIn = true;
+        } catch { /* try PATH Codex, then device code */ }
+        if (!signedIn) {
+          const codexPath = pathCodexBinary(env);
+          if (codexPath) {
+            try {
+              const result = await (grokDeps.spawnCodexLogin ?? spawnCodexLogin)({ deviceAuth: false, codexPath });
+              signedIn = result.ok;
+            } catch { /* device code remains available */ }
+          }
+        }
+        if (signedIn) io.print('  → ChatGPT/Codex 로그인을 씁니다.');
+        else io.print('  브라우저 로그인이 안 됐습니다 — 코드로 이어갑니다');
+      }
+      if (!signedIn) {
+        io.print('  코드로 로그인합니다…');
+        try {
+          await (grokDeps.loginWithCodex ?? loginWithCodex)({
+            onProgress: (p) => {
+              if (p.type === 'user_code') {
+                io.print('');
+                io.print(`    1) 아무 브라우저에서 열기: ${p.loginUrl}`);
+                io.print(`    2) 코드 입력:             ${p.userCode}`);
+                io.print('');
+                assistCodexDeviceLogin(io, p.loginUrl ?? CODEX_DEVICE_LOGIN_URL, p.userCode ?? '', grokDeps);
+                io.print('  로그인을 기다리는 중…');
+              }
+              if (p.type === 'saved') io.print('  로그인했습니다. 저장했습니다.');
+            },
+          });
+        } catch (err: any) {
+          io.print(`  ! OAuth failed: ${err?.message ?? err}`);
+          io.print(`    Navigate to ${CODEX_DEVICE_LOGIN_URL} manually,`);
+          io.print(`    or re-run \`elanous login openai-codex\` / \`elanous codex setup\` later.`);
+        }
       }
     } else if (mode === 'apikey') {
       // PR-Δ14 — askValidated catches blank/short/whitespace before
@@ -493,6 +652,8 @@ async function askLLM(
       );
       if (key.trim()) out.apiKey = key.trim();
       else if (current.apiKey) out.apiKey = current.apiKey;
+    } else if (mode === 'oauth-keep') {
+      io.print('  → using your existing ChatGPT/Codex login.');
     } else {
       io.print('  → skipped. Run `elanous codex setup` or `elanous login openai-codex` later.');
     }
@@ -1163,6 +1324,13 @@ export interface RunWizardOpts {
   grokDeps?: GrokOnboardingDeps;
   /** Internal ownership transfer for wrappers that explicitly complete IO. */
   deferComplete?: boolean;
+  /** Post-save connections; injection keeps wizard tests off the real daemon/token store. */
+  continueHereDeps?: {
+    showNexus?: () => Promise<Pick<NexusShowResult, 'urls' | 'status' | 'instance'>>;
+    probeTailscale?: () => Promise<TailscaleProbe>;
+    issueToken?: () => Pick<IssuedTempToken, 'token'>;
+    renderQr?: (link: string) => string | undefined;
+  };
 }
 
 /** Pick the default IO. TTY → `fullScreenIO` (Phase 5: cleared
@@ -1206,7 +1374,7 @@ export class OnboardingRefusedError extends Error {
 export function handleOnboardingRefusal(error: unknown, entrance: 'agent' | 'other'): boolean {
   if (!(error instanceof OnboardingRefusedError) || error.code !== 'onboarding-refused') return false;
   if (entrance === 'agent' && error.reason === 'non-tty') {
-    console.error('elanous agent needs a configured LLM. Run `elanous setup` in a terminal, or `elanous setup --non-interactive --config <path>` for unattended setup.');
+    console.error(`elanous agent needs a configured LLM. Run \`elanous onboarding\` in a terminal, or ${unattendedSetupHint()} for unattended setup.`);
   } else {
     console.error(error.message);
   }
@@ -1231,7 +1399,7 @@ function refuseInteractiveOnboardingIfNeeded(opts: RunWizardOpts, path: string):
   if (nonTTY) {
     throw new OnboardingRefusedError(
       '대화형 온보딩은 stdin TTY가 있는 자리에서만 실행할 수 있다. '
-      + '무인 설정은 `elanous setup --non-interactive --config <path>`를 사용하라.',
+      + `무인 설정은 ${unattendedSetupHint()}를 사용하라.`,
       'non-tty',
     );
   }
@@ -1375,14 +1543,107 @@ export async function runOnboarding(opts: RunWizardOpts = {}): Promise<UserConfi
     io.print('');
     io.print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
     io.print(`  ${m.setupComplete}`);
+    // ER1 — first-run consent notice (default on · 대표 10-01): what is sent and how to turn it off.
+    io.print('  오류가 나면 운영팀에 자동으로 알립니다(오류 내용·버전·무작위 설치 ID — 이름·메일 없이). 끄기: elanous config set errorReports.enabled false');
     io.print(`  Provider : ${marked.llm.provider}${marked.llm.model ? ` (${marked.llm.model})` : ''}`);
-    io.print(`  Skills   : ${marked.skills.activeSet} — ${marked.skills.dirs.length} dir(s)`);
-    for (const d of marked.skills.dirs) io.print(`             ${d}`);
+    // EN5 — show what the loader will actually read (resolveSkillSources), not the raw preset fields.
+    const skillSources = resolveSkillSources(marked).filter((source) => source.enabled);
+    io.print(`  Skills   : ${marked.skills.activeSet} — ${skillSources.length} dir(s)`);
+    for (const source of skillSources) io.print(`             ${source.path}${source.kind === 'preset' ? '' : `  (${source.id})`}`);
+    // EN9 — skills the person already has in another agent: one line, one command (registers in place, no copy).
+    try {
+      const { CONNECT_AGENTS, planConnect } = await import('./skills/connect.js');
+      const active = defaultSkillDirs(marked);
+      for (const agent of CONNECT_AGENTS) {
+        const plan = planConnect(agent, active);
+        if (plan.state === 'new') io.print(`  쓰던 스킬 ${plan.skills.length}개 찾음(${agent}) — 가져오려면: elanous connect ${agent}`);
+      }
+    } catch { /* advisory */ }
+    // EN13 — a bot the person already runs elsewhere: one line, one command (values never shown).
+    try {
+      const { channelImportHint } = await import('./channel-import/run.js');
+      const hint = channelImportHint();
+      if (hint) io.print(`  ${hint}`);
+    } catch { /* advisory */ }
     io.print(`  Obsidian : ${marked.obsidian.vault}`);
     io.print(`  Telegram : ${marked.telegram.enabled ? 'enabled' : 'disabled'}`);
     io.print(`  Discord  : ${marked.discord.enabled ? 'enabled' : 'disabled'}`);
     io.print(`  ${i18nFormat(m.setupRerunHint, { cmd: 'elanous setup' })}`);
     io.print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+    const interactive = !io.nonInteractive && !!(opts.io || input.isTTY);
+    let shown: Pick<NexusShowResult, 'urls' | 'status' | 'instance'> | undefined;
+    try {
+      const showNexus = opts.continueHereDeps?.showNexus ?? (async () => {
+        const { runNexusShow } = await import('./cli/nexus-show.js');
+        return runNexusShow({ format: 'json', out: { log: () => {}, error: () => {} } });
+      });
+      shown = await showNexus();
+    } catch { /* Config was saved; daemon discovery is advisory. */ }
+    const daemonRunning = shown?.status === 'unregistered'
+      || (shown?.status === 'registered' && shown.instance?.alive === true);
+    const pwaUrl = daemonRunning ? shown?.urls?.pwa.tailnet ?? shown?.urls?.pwa.loopback : undefined;
+    let phoneLink: string | undefined;
+    if (interactive && daemonRunning && shown?.urls?.rest) {
+      try {
+        const { pickPhoneBase, endpointFromBaseUrl, buildPhoneConnectLink } = await import('./cli/phone-link.js');
+        const picked = pickPhoneBase(shown.urls.rest);
+        const endpoint = endpointFromBaseUrl(picked.base);
+        if (endpoint) {
+          const issued = opts.continueHereDeps?.issueToken
+            ? opts.continueHereDeps.issueToken()
+            : await (async () => {
+                const { issueTempToken, parseTtl } = await import('./auth/temp-tokens.js');
+                return issueTempToken({ ttlMs: parseTtl('24h'), label: 'phone' });
+              })();
+          phoneLink = buildPhoneConnectLink(endpoint, issued.token);
+          try { debug.log('onboarding.continue-here', 'phone-link-issued', { kind: picked.kind, tls: endpoint.tls, temp: true }); }
+          catch { /* Logging must not interrupt setup. */ }
+        }
+      } catch { /* No token/link on failure; show the manual command instead. */ }
+    }
+    let tailscale: { host?: string } | undefined;
+    let installed = false;
+    let alive = false;
+    let probeTimer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const probe = opts.continueHereDeps?.probeTailscale ?? (async () => {
+        const { probeTailscale } = await import('./nexus/onboarding/tailscale-probe.js');
+        return probeTailscale({ timeoutMs: 2000 });
+      });
+      const status = await Promise.race([
+        probe(),
+        new Promise<undefined>(resolve => { probeTimer = setTimeout(() => resolve(undefined), 2000); }),
+      ]);
+      if (status) {
+        installed = status.installed;
+        alive = status.alive;
+        // A bare hostname has no HTTPS certificate — offer the command without an address.
+        if (installed && alive) tailscale = status.magicDnsHost ? { host: status.magicDnsHost } : {};
+      }
+    } catch { /* Tailscale discovery is advisory. */ }
+    finally { if (probeTimer) clearTimeout(probeTimer); }
+    try { debug.log('onboarding.tailscale', 'probed', { installed, alive, offered: !!tailscale }); }
+    catch { /* Logging must not interrupt setup. */ }
+    const directions = continueHereLines({ daemonRunning, pwaUrl, phoneLink, telegramEnabled: marked.telegram.enabled, interactive, tailscale });
+    if (io.nonInteractive) {
+      for (const line of directions) process.stdout.write(`${line}\n`);
+    } else {
+      io.print('');
+      for (const line of directions) io.print(line);
+    }
+    if (interactive && phoneLink) {
+      try {
+        const renderQr = opts.continueHereDeps?.renderQr ?? ((link: string) => {
+          const qr = spawnSync('qrencode', ['-t', 'ANSIUTF8', link], { encoding: 'utf8' });
+          return qr.status === 0 ? qr.stdout : undefined;
+        });
+        const qr = renderQr(phoneLink);
+        if (qr) io.print(qr);
+      } catch { /* qrencode is optional, exactly as with phone link. */ }
+    }
+    try { debug.log('onboarding.continue-here', 'shown', { daemonRunning, interactive, phoneLinkIssued: !!phoneLink, telegramEnabled: marked.telegram.enabled }); }
+    catch { /* Logging must not interrupt setup. */ }
     if (!opts.deferComplete) io.complete?.();
     return marked;
   } finally {

package/src/persona/presets.ts

@@ -0,0 +1,105 @@
+// PS1 — 페르소나 프리셋(MK 문면 · persona-presets/<id>.yaml)을 «내 페르소나»로 만든다.
+// 용어: «페르소나»(대표 10-01) — 사용자가 고르고 꾸미는 AI 동료. ⚠️ `SessionSurfaceId`(이름만 Surface 인 캐릭터 축) ·
+// `modelTier.persona`(모델 등급 축)와는 «다른 것»이다 — 여기서 만드는 것은 기존 페르소나 저장소(`resolveStatePersonaDir()`,
+// Discord·PWA 가 이미 읽는 `<id>.yaml`)의 한 파일이다. 프리셋 원본은 고치지 않는다.
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse, stringify } from 'yaml';
+
+export interface PersonaPreset {
+  personaId: string;
+  displayName: string;
+  names: string[];
+  role: string;
+  title?: string | null;
+  oneLine: string;
+  voice: { rule: string; examples: string[] };
+  tasks: Array<{ when: string; what: string }>;
+  tools: Array<{ name: string; from: string; optional?: boolean }>;
+  firstQuestions: string[];
+  askBefore?: string[];
+  doesNot: string[];
+  forWhom: string;
+}
+
+export interface PresetCommon { loop_start?: string; always_ask?: string[]; memory?: string; title?: string }
+
+/** `persona-presets/` shipped with this package (src/persona → ../../persona-presets). */
+export function presetsDir(): string {
+  return join(import.meta.dir, '..', '..', 'persona-presets');
+}
+
+export function loadPresetIndex(dir = presetsDir()): { order: string[]; common: PresetCommon } {
+  const index = parse(readFileSync(join(dir, '_index.yaml'), 'utf8')) as { presets?: string[]; common?: PresetCommon };
+  return { order: index.presets ?? [], common: index.common ?? {} };
+}
+
+/** Presets in the index order; files not in the index come last (sorted). */
+export function loadPresets(dir = presetsDir()): PersonaPreset[] {
+  if (!existsSync(dir)) return [];
+  const { order } = loadPresetIndex(dir);
+  const files = readdirSync(dir).filter((f) => f.endsWith('.yaml') && !f.startsWith('_')).map((f) => f.slice(0, -5));
+  const ids = [...order.filter((id) => files.includes(id)), ...files.filter((id) => !order.includes(id)).sort()];
+  return ids.map((id) => parse(readFileSync(join(dir, `${id}.yaml`), 'utf8')) as PersonaPreset);
+}
+
+/** Find by id or by any of its names (case-insensitive). */
+export function findPreset(presets: readonly PersonaPreset[], query: string): PersonaPreset | undefined {
+  const q = query.trim().toLowerCase();
+  return presets.find((p) => p.personaId === q) ?? presets.find((p) => p.names.some((n) => n.toLowerCase() === q) || p.role === query.trim());
+}
+
+/** The persona's working instructions, assembled from the preset (and the shared rules). */
+export function presetSystemPrompt(p: PersonaPreset, common: PresetCommon, name: string): string {
+  const lines = [
+    `너는 «${name}», ${p.role}다. ${p.oneLine}`,
+    '',
+    `말투: ${p.voice.rule}`,
+    ...p.voice.examples.map((e) => `  예) ${e}`),
+    '',
+    '맡은 일:',
+    ...p.tasks.map((t) => `- ${t.when}: ${t.what}`),
+    '',
+    `처음 만나면 묻는다: ${p.firstQuestions.join(' / ')}`,
+    `먼저 확인을 받는다: ${[...(p.askBefore ?? []), ...(common.always_ask ?? [])].join(' · ')}`,
+    '하지 않는다:',
+    ...p.doesNot.map((d) => `- ${d}`),
+  ];
+  if (common.loop_start) lines.push('', `시작 방식: ${common.loop_start}`);
+  return lines.join('\n');
+}
+
+/** ASCII id for the profile file: from --name when it is latin, else the preset id; `-2`, `-3`… when taken. */
+export function choosePersonaId(preset: PersonaPreset, name: string | undefined, taken: ReadonlySet<string>): string {
+  const fromName = name?.toLowerCase().normalize('NFKD').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const base = fromName && /^[a-z0-9]/.test(fromName) ? fromName.slice(0, 32) : preset.personaId;
+  if (!taken.has(base)) return base;
+  for (let i = 2; ; i++) if (!taken.has(`${base}-${i}`)) return `${base}-${i}`;
+}
+
+/** The profile YAML written to the persona store (the existing loader reads it; `preset` records where it came from). */
+export function presetToProfileYaml(p: PersonaPreset, common: PresetCommon, opts: { personaId: string; name?: string; title?: string }): string {
+  const name = opts.name?.trim() || p.names[0] || p.displayName;
+  const title = opts.title ?? p.title ?? undefined;
+  const profile = {
+    personaId: opts.personaId,
+    displayName: opts.name?.trim() ? `${opts.name.trim()} · ${p.role}` : p.displayName,
+    description: p.oneLine,
+    systemPrompt: presetSystemPrompt(p, common, name),
+    preset: { id: p.personaId, role: p.role, ...(title ? { title } : {}), tools: p.tools.map((t) => t.name), firstQuestions: p.firstQuestions },
+  };
+  return `# 프리셋 «${p.personaId}» 에서 만든 페르소나 — elanous persona add (원본: persona-presets/${p.personaId}.yaml)\n${stringify(profile, { lineWidth: 0 })}`;
+}
+
+/** Short block for `persona show` and `persona list`. */
+export function describePreset(p: PersonaPreset): string[] {
+  return [
+    `${p.displayName} — ${p.role}${p.title ? ` (${p.title})` : ''}`,
+    `  ${p.oneLine}`,
+    `  누구에게: ${p.forWhom}`,
+    `  맡는 일: ${p.tasks.map((t) => `${t.when} ${t.what}`).join(' / ')}`,
+    `  쓰는 도구: ${p.tools.map((t) => (t.optional ? `${t.name}(선택 · 따로 설치)` : t.name)).join(', ')}`,
+    `  처음 묻는 것: ${p.firstQuestions.join(' / ')}`,
+    `  하지 않는 것: ${p.doesNot.join(' / ')}`,
+  ];
+}

package/src/plugins/maker/node-install.ts

@@ -0,0 +1,92 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { resolve, sep } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { debug } from '../../debug/log.js';
+import { listNodeKinds } from '../../graph-kinds/registry.js';
+import { loadPluginNodes } from '../../graph-kinds/plugin-nodes.js';
+import { loadPluginManifestFromDir } from '../core/manifest.js';
+import { installPlugin, type InstalledPlugin } from '../install/plugin-install.js';
+import { addNode, type AddNodeOptions, type AddNodeResult } from './node-maker.js';
+
+export interface AddAndInstallNodeOptions extends Omit<AddNodeOptions, 'deps'> {
+  /** Accept the plugin's requested capabilities without asking (same meaning as `plugin add --yes`). */
+  yes?: boolean;
+  deps?: {
+    addNode?: typeof addNode;
+    installPlugin?: typeof installPlugin;
+    consent?: (capabilities: string[]) => boolean | Promise<boolean>;
+    sync?: (installed: InstalledPlugin) => void | Promise<void>;
+    listNodeKinds?: typeof listNodeKinds;
+    codex?: NonNullable<AddNodeOptions['deps']>['codex'];
+  };
+}
+
+export interface AddAndInstallNodeResult extends Omit<AddNodeResult, 'status' | 'timings'> {
+  status: 'installed' | 'failed';
+  plugin?: string;
+  installedPath?: string;
+  timings: AddNodeResult['timings'] & { install: number; sync: number };
+}
+
+function installedNodeManifest(installed: InstalledPlugin, kind: string) {
+  const { manifest, inferred } = loadPluginManifestFromDir(installed.path, { id: installed.name });
+  if (inferred || manifest.id !== installed.name || manifest.version !== installed.version) {
+    throw new Error(`installed plugin manifest mismatch: ${installed.name}@${installed.version}`);
+  }
+  const root = realpathSync(installed.path);
+  const matches = (manifest.contributes.nodes ?? []).some(path => {
+    const file = realpathSync(resolve(root, path));
+    if (!path.startsWith('./') || !file.startsWith(`${root}${sep}`)) throw new Error(`unsafe installed node path: ${path}`);
+    const node: unknown = parseYaml(readFileSync(file, 'utf8'));
+    return node !== null && typeof node === 'object' && !Array.isArray(node)
+      && (node as Record<string, unknown>).kind === kind
+      && (node as Record<string, unknown>).graph === 'workflow';
+  });
+  if (!matches) throw new Error(`installed node not found: ${installed.name}:${kind}`);
+  return manifest;
+}
+
+export async function addAndInstallNode({ dir, request, kind, yes, deps }: AddAndInstallNodeOptions): Promise<AddAndInstallNodeResult> {
+  const added = await (deps?.addNode ?? addNode)({ dir, request, kind,
+    ...(deps?.codex ? { deps: { codex: deps.codex } } : {}),
+  });
+  const result: AddAndInstallNodeResult = {
+    ...added, status: 'failed', timings: { ...added.timings, install: 0, sync: 0 },
+  };
+  if (added.status !== 'added') return result;
+
+  try {
+    const startedInstall = performance.now();
+    let installed: InstalledPlugin;
+    try {
+      installed = await (deps?.installPlugin ?? installPlugin)(added.dir, {
+        ...(yes === undefined ? {} : { yes }),
+        consent: deps?.consent ?? (() => false),
+      });
+    } finally {
+      result.timings.install = Math.round(performance.now() - startedInstall);
+      debug.log('plugin.node-install', 'install', { ms: result.timings.install });
+    }
+    result.plugin = installed.name;
+    result.installedPath = installed.path;
+    const startedSync = performance.now();
+    try {
+      const manifest = installedNodeManifest(installed, added.kind);
+      if (deps?.sync) await deps.sync(installed);
+      else {
+        const loaded = loadPluginNodes(installed.path, manifest);
+        if (loaded.errors.length) throw new Error(`node sync failed: ${loaded.errors.join('; ')}`);
+      }
+      const registered = (deps?.listNodeKinds ?? listNodeKinds)('workflow')
+        .some(entry => entry.plugin === installed.name && entry.kind === `${installed.name}:${added.kind}`);
+      if (!registered) throw new Error(`node kind not registered: ${installed.name}:${added.kind}`);
+      result.status = 'installed';
+    } finally {
+      result.timings.sync = Math.round(performance.now() - startedSync);
+      debug.log('plugin.node-install', 'sync', { ms: result.timings.sync, status: result.status });
+    }
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}