deel-local-cli 0.5.0

package/src/backend/probe.js

@@ -0,0 +1,355 @@
+// 게이트웨이/로컬서버가 "에이전트를 돌릴 수 있는지"를 실제 요청으로 확인한다.
+// 각 검사는 { id, label, status, detail, ms } 를 돌려준다.
+//   ok   되는 것을 확인함
+//   no   안 됨 (기능에 직접 영향)
+//   warn 되긴 하는데 조건이 붙음
+//   skip 앞 검사가 실패해 확인 불가
+import { req, headersFor, serverMessage } from './http.js';
+
+const READ_TOOL = {
+  type: 'function',
+  function: {
+    name: 'read_file',
+    description: '파일 하나의 내용을 읽는다',
+    parameters: {
+      type: 'object',
+      properties: { path: { type: 'string', description: '읽을 파일 경로' } },
+      required: ['path'],
+    },
+  },
+};
+
+// 규격별 요청 만들기 — 이 함수 하나가 openai/ollama 차이를 흡수한다.
+function build(shape, { model, messages, tools, stream, json, think, maxTokens = 128 }) {
+  if (shape === 'ollama') {
+    const body = { model, messages, stream: !!stream, options: { num_predict: maxTokens } };
+    if (tools) body.tools = tools;
+    if (json) body.format = json;
+    if (think !== undefined) body.think = think;
+    return { path: '/api/chat', body };
+  }
+  const body = { model, messages, stream: !!stream, max_tokens: maxTokens };
+  if (tools) { body.tools = tools; body.tool_choice = 'auto'; }
+  if (json) {
+    body.response_format = { type: 'json_schema', json_schema: { name: 'probe', schema: json, strict: true } };
+  }
+  if (think !== undefined) body.reasoning_effort = think;
+  return { path: '/chat/completions', body };
+}
+
+// 응답에서 본문과 도구호출을 꺼낸다.
+function extract(shape, json) {
+  if (shape === 'ollama') {
+    const m = json?.message ?? {};
+    return { content: m.content ?? '', toolCalls: m.tool_calls ?? [], thinking: m.thinking ?? '' };
+  }
+  const m = json?.choices?.[0]?.message ?? {};
+  return { content: m.content ?? '', toolCalls: m.tool_calls ?? [], thinking: m.reasoning_content ?? '' };
+}
+
+// 추론 모델일 때 기본 대화 칸에 덧붙일 설명.
+function c_note(retried) {
+  return retried ? ' (추론 모델 — 사고를 끄고 다시 물어 확인)' : ' (추론 모델)';
+}
+
+const SKIPPED = [
+  ['system', '시스템 메시지'],
+  ['stream', '스트리밍'],
+  ['tools', '도구 호출'],
+  ['toolresult', '도구 결과 되돌리기'],
+  ['json', '구조적 출력'],
+  ['think', '추론 강도 조절'],
+  ['ctx', '컨텍스트 길이'],
+];
+
+export async function probe(conn, onStep = () => {}) {
+  const { kind: shape, base, auth, model } = conn;
+  const key = conn.key ?? '';
+  const H = () => headersFor(auth, key);
+  const url = (p) => `${base}${p}`;
+  const results = [];
+  const facts = { shape, base, auth, model };
+
+  const add = (r) => { results.push(r); onStep(r); return r; };
+  const call = (opts) => {
+    const { path, body } = build(shape, { model, ...opts });
+    return req(url(path), {
+      method: 'POST',
+      headers: H(),
+      body,
+      timeout: opts.timeout ?? 60000,
+      stream: opts.stream,
+    });
+  };
+
+  // 1. 기본 대화 — 이게 안 되면 나머지는 볼 필요가 없다.
+  //    추론 모델은 본문이 전부 thinking 으로 가고 토큰 상한에 잘린다.
+  //    그걸 "안됨"으로 볼 수 없으므로, 사고를 끄고 넉넉히 한 번 더 물어본다.
+  const ASK = { messages: [{ role: 'user', content: '1+1은? 숫자만 답하세요.' }] };
+  let basic = await call({ ...ASK, maxTokens: 256 });
+  let got = basic.ok ? extract(shape, basic.json) : { content: '', thinking: '' };
+  let thinkingModel = false;
+  let retried = false;
+
+  if (basic.ok && !got.content && got.thinking) {
+    thinkingModel = true;
+    retried = true;
+    const second = await call({ ...ASK, maxTokens: 1024, think: false, timeout: 90000 });
+    if (second.ok) {
+      const e2 = extract(shape, second.json);
+      if (e2.content) { basic = second; got = e2; }
+      else {
+        // 사고를 못 끄는 서버 — 상한만 크게 올려 한 번 더.
+        const third = await call({ ...ASK, maxTokens: 2048, timeout: 120000 });
+        if (third.ok && extract(shape, third.json).content) { basic = third; got = extract(shape, third.json); }
+      }
+    }
+  }
+
+  const basicText = got.content;
+  const basicOk = basic.ok && !!basicText;
+  facts.thinkingModel = thinkingModel;
+  // 사고를 끌 수 있는 모델이면 이후 검사에서 꺼서 토큰과 시간을 아낀다.
+  const quiet = shape === 'ollama' && thinkingModel ? { think: false, maxTokens: 512 } : {};
+
+  add({
+    id: 'chat',
+    label: '기본 대화',
+    status: basicOk ? 'ok' : 'no',
+    detail: basicOk
+      ? `응답 "${basicText.trim().slice(0, 24)}"` + (thinkingModel ? c_note(retried) : '')
+      : basic.ok
+        ? got.thinking
+          ? '사고만 나오고 본문이 안 나옵니다 — 토큰 상한을 크게 올려야 합니다'
+          : '응답이 비어 있습니다 — 모델 이름을 확인하세요'
+        : serverMessage(basic),
+    ms: basic.ms,
+  });
+  if (!basicOk) {
+    for (const [id, label] of SKIPPED) {
+      add({ id, label, status: 'skip', detail: '기본 대화가 안 되어 확인 불가', ms: 0 });
+    }
+    return { facts, results };
+  }
+
+  // 2. 시스템 메시지 — 규칙과 스킬이 먹느냐가 여기 달렸다.
+  const sys = await call({
+    ...quiet,
+    messages: [
+      { role: 'system', content: '너는 무슨 질문을 받든 정확히 DEEL 한 단어만 답한다.' },
+      { role: 'user', content: '안녕하세요' },
+    ],
+  });
+  const sysHit = sys.ok && /DEEL/i.test(extract(shape, sys.json).content);
+  add({
+    id: 'system',
+    label: '시스템 메시지',
+    status: sys.ok ? (sysHit ? 'ok' : 'warn') : 'no',
+    detail: sys.ok
+      ? sysHit ? '지시를 따름' : '전달은 되나 모델이 잘 안 따름 — 규칙·스킬이 약하게 먹습니다'
+      : serverMessage(sys),
+    ms: sys.ms,
+  });
+
+  // 3. 스트리밍 — 화면이 한 글자씩 흐르느냐.
+  const st = await call({
+    ...quiet,
+    messages: [{ role: 'user', content: '1부터 20까지 세어보세요.' }],
+    stream: true,
+    timeout: 45000,
+  });
+  let chunks = 0;
+  let firstMs = 0;
+  if (st.ok && st.res?.body) {
+    const t0 = Date.now();
+    try {
+      const reader = st.res.body.getReader();
+      const dec = new TextDecoder();
+      while (chunks < 400) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const text = dec.decode(value, { stream: true });
+        const hits = (text.match(/(^|\n)data:|"done"\s*:/g) ?? []).length;
+        if (hits && !firstMs) firstMs = Date.now() - t0;
+        chunks += hits || (text.trim() ? 1 : 0);
+      }
+      reader.cancel().catch(() => {});
+    } catch {}
+  }
+  add({
+    id: 'stream',
+    label: '스트리밍',
+    status: chunks > 2 ? 'ok' : st.ok ? 'warn' : 'no',
+    detail: chunks > 2
+      ? `조각 ${chunks}개, 첫 응답 ${firstMs}ms`
+      : st.ok ? '한 번에 옵니다 — 화면은 스피너로 대체합니다' : serverMessage(st),
+    ms: st.ms,
+  });
+  facts.streaming = chunks > 2;
+
+  // 4. 도구 호출 — 에이전트의 생사가 걸린 검사.
+  const tl = await call({
+    ...quiet,
+    messages: [{ role: 'user', content: 'config.json 파일을 읽어 주세요.' }],
+    tools: [READ_TOOL],
+    maxTokens: 512,
+    timeout: 90000,
+  });
+  const tcalls = tl.ok ? extract(shape, tl.json).toolCalls : [];
+  const gotCall = tcalls.length > 0;
+  const argOk = gotCall && JSON.stringify(tcalls[0]?.function?.arguments ?? '').includes('config');
+  add({
+    id: 'tools',
+    label: '도구 호출',
+    status: gotCall ? (argOk ? 'ok' : 'warn') : 'no',
+    detail: gotCall
+      ? `${tcalls[0]?.function?.name} 호출됨${argOk ? '' : ' — 인자가 부정확, 편집 신뢰성 작업이 더 필요합니다'}`
+      : tl.ok ? '도구를 안 부르고 글로만 답합니다' : serverMessage(tl),
+    ms: tl.ms,
+  });
+  facts.tools = gotCall;
+
+  // 5. 도구 결과 되돌리기 — 여러 턴이 이어지느냐. 에이전트 루프의 전제다.
+  if (gotCall) {
+    const tc = tcalls[0];
+    const callId = tc.id ?? 'call_1';
+    const assistantMsg = shape === 'ollama'
+      ? { role: 'assistant', content: '', tool_calls: tcalls }
+      : { role: 'assistant', content: null, tool_calls: [{ id: callId, type: 'function', function: tc.function }] };
+    const toolMsg = shape === 'ollama'
+      ? { role: 'tool', tool_name: tc.function?.name, content: '{"port": 7099}' }
+      : { role: 'tool', tool_call_id: callId, content: '{"port": 7099}' };
+    const rt = await call({
+      ...quiet,
+      timeout: 90000,
+      messages: [
+        { role: 'user', content: 'config.json 파일을 읽어 주세요.' },
+        assistantMsg,
+        toolMsg,
+        { role: 'user', content: 'port 값이 몇인가요? 숫자만 답하세요.' },
+      ],
+      tools: [READ_TOOL],
+      maxTokens: 256,
+    });
+    const said = rt.ok ? extract(shape, rt.json).content : '';
+    add({
+      id: 'toolresult',
+      label: '도구 결과 되돌리기',
+      status: rt.ok ? (/7099/.test(said) ? 'ok' : 'warn') : 'no',
+      detail: rt.ok
+        ? /7099/.test(said) ? '결과를 읽고 이어서 답함' : `받긴 하나 활용이 약함 ("${said.trim().slice(0, 20)}")`
+        : serverMessage(rt),
+      ms: rt.ms,
+    });
+  } else {
+    add({ id: 'toolresult', label: '도구 결과 되돌리기', status: 'skip', detail: '도구 호출이 안 되어 확인 불가', ms: 0 });
+  }
+
+  // 6. 구조적 출력 — 편집 형식을 강제할 수 있느냐.
+  const schema = {
+    type: 'object',
+    properties: { answer: { type: 'number' } },
+    required: ['answer'],
+    additionalProperties: false,
+  };
+  // 한 번은 흔들릴 수 있으므로 실패하면 한 번만 더 본다.
+  let js = null;
+  let parsed = null;
+  let raw = '';
+  for (let attempt = 0; attempt < 2 && !parsed; attempt++) {
+    js = await call({
+      ...quiet,
+      messages: [{ role: 'user', content: '3 곱하기 7은?' }],
+      json: schema,
+      maxTokens: 512,
+      timeout: 90000,
+    });
+    if (!js.ok) break;
+    raw = extract(shape, js.json).content ?? '';
+    try { parsed = JSON.parse(raw); } catch {}
+  }
+  const jsonOk = !!(parsed && 'answer' in parsed);
+  add({
+    id: 'json',
+    label: '구조적 출력',
+    status: jsonOk ? 'ok' : js?.ok ? 'warn' : 'no',
+    detail: jsonOk
+      ? `스키마대로 반환 (answer=${parsed.answer})`
+      : js?.ok
+        ? `스키마를 안 지킴 — 받은 값 ${JSON.stringify(raw.slice(0, 60))} · 편집 형식을 프롬프트로 강제합니다`
+        : serverMessage(js ?? {}),
+    ms: js?.ms ?? 0,
+  });
+  facts.json = jsonOk;
+
+  // 7. 추론 강도 조절 — 낮음/높음이 실제로 다른 결과를 내느냐.
+  //    상한에 걸리면 둘 다 같은 숫자가 나와 비교가 무의미해진다. 넉넉히 준다.
+  const THINK_CAP = 1500;
+  const seen = [];
+  for (const lv of ['low', 'high']) {
+    const r = await call({
+      messages: [{ role: 'user', content: '17 곱하기 23은? 계산 과정을 보이세요.' }],
+      think: lv,
+      maxTokens: THINK_CAP,
+      timeout: 120000,
+    });
+    if (r.ok) {
+      const e = extract(shape, r.json);
+      seen.push({
+        lv,
+        ms: r.ms,
+        thought: (e.thinking ?? '').length,
+        out: r.json?.usage?.completion_tokens ?? r.json?.eval_count ?? 0,
+        capped: (r.json?.done_reason ?? r.json?.choices?.[0]?.finish_reason) === 'length',
+      });
+    } else {
+      seen.push({ lv, ms: r.ms, err: serverMessage(r) });
+    }
+  }
+  const bothOk = seen.every((s) => !s.err);
+  const capped = bothOk && seen.every((s) => s.capped);
+  // 사고 길이가 눈에 띄게 다르거나, 출력량이 20% 넘게 차이나야 "먹는다"고 본다.
+  const thoughtGap = bothOk ? Math.abs(seen[0].thought - seen[1].thought) : 0;
+  const outGap = bothOk ? Math.abs(seen[0].out - seen[1].out) : 0;
+  const differs = bothOk && !capped &&
+    (thoughtGap > Math.max(80, seen[0].thought * 0.2) || outGap > Math.max(20, seen[0].out * 0.2));
+  const fmt = (s) => `${s.lv === 'low' ? '낮음' : '높음'} 사고 ${s.thought}자/출력 ${s.out}토큰/${s.ms}ms`;
+  add({
+    id: 'think',
+    label: '추론 강도 조절',
+    status: !bothOk ? 'no' : capped ? 'warn' : differs ? 'ok' : 'warn',
+    detail: !bothOk
+      ? `파라미터 거부됨 — ${seen.find((s) => s.err)?.err}`
+      : capped
+        ? `둘 다 토큰 상한(${THINK_CAP})에 걸려 비교 불가 — 루프 층에서 조절합니다`
+        : differs
+          ? `${fmt(seen[0])} · ${fmt(seen[1])}`
+          : `차이 없음 (${fmt(seen[0])} · ${fmt(seen[1])}) — 루프 층에서 조절합니다`,
+    ms: seen.reduce((a, s) => a + (s.ms ?? 0), 0),
+  });
+  facts.think = differs;
+
+  // 8. 컨텍스트 길이 — 파일을 몇 개까지 한 번에 읽힐 수 있느냐.
+  let ctx = null;
+  let ctxNote = '';
+  if (shape === 'ollama') {
+    const show = await req(`${base}/api/show`, { method: 'POST', headers: H(), body: { model }, timeout: 20000 });
+    const info = show.json?.model_info ?? {};
+    const k = Object.keys(info).find((x) => /context_length/.test(x));
+    if (k) { ctx = info[k]; ctxNote = '모델 정보에서 읽음'; }
+  } else {
+    const m = await req(`${base}/models/${encodeURIComponent(model)}`, { headers: H(), timeout: 15000 });
+    ctx = m.json?.context_window ?? m.json?.max_context_length ?? m.json?.context_length ?? null;
+    if (ctx) ctxNote = '모델 정보에서 읽음';
+  }
+  add({
+    id: 'ctx',
+    label: '컨텍스트 길이',
+    status: ctx ? 'ok' : 'warn',
+    detail: ctx ? `${ctx.toLocaleString()} 토큰 (${ctxNote})` : '서버가 알려주지 않음 — 설정에서 직접 지정합니다',
+    ms: 0,
+  });
+  facts.ctx = ctx;
+
+  return { facts, results };
+}

package/src/commands.js

@@ -0,0 +1,327 @@
+// 슬래시 명령. 이름은 Claude Code / Codex 관례에 맞춘다.
+import { writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { c, say, rule, pad, bar, mark, width } from './ui/ansi.js';
+import { pick } from './ui/prompt.js';
+import { load, save, resolveKey } from './config.js';
+import { TOOLS } from './tools/index.js';
+import { loadCommand } from './skills/discover.js';
+
+const THINK_LEVELS = ['off', 'low', 'medium', 'high', 'max'];
+const MODES = {
+  auto: '자율 — 전부 알아서. 되돌리기가 안전망',
+  confirm: '확인 — 되돌릴 수 없는 것만 물어봄',
+  strict: '엄격 — 파일 변경·명령 전부 물어봄',
+};
+
+export const COMMANDS = {
+  help:    { desc: '명령 목록' },
+  clear:   { desc: '대화 비우기' },
+  context: { desc: '컨텍스트 사용량 보기' },
+  compact: { desc: '오래된 대화 줄이기' },
+  model:   { desc: '모델·연결 바꾸기' },
+  think:   { desc: '추론 강도 (off/low/medium/high/max)', arg: '<수준>' },
+  mode:    { desc: '실행 모드 (auto/confirm/strict)', arg: '<모드>' },
+  undo:    { desc: '직전 작업 되돌리기', arg: '[턴수]' },
+  tools:   { desc: '쓸 수 있는 도구 보기' },
+  skills:  { desc: '스킬 보기·검색·골라 올리기', arg: '[검색어|all|off]' },
+  cost:    { desc: '이번 세션 사용량' },
+  status:  { desc: '연결 상태' },
+  init:    { desc: 'DEEL.md 규칙 파일 만들기' },
+  exit:    { desc: '끝내기' },
+  quit:    { desc: '끝내기' },
+};
+
+// 반환: { handled, exit? }  handled=false 면 모델에게 보낸다.
+export async function handle(line, session, ctx) {
+  if (!line.startsWith('/')) return { handled: false };
+  const [raw, ...rest] = line.slice(1).trim().split(/\s+/);
+  const name = raw.toLowerCase();
+  const arg = rest.join(' ');
+
+  switch (name) {
+    case 'help': return help(), { handled: true };
+    case 'exit':
+    case 'quit': return { handled: true, exit: true };
+
+    case 'clear':
+      session.clear();
+      say(`  ${mark.ok} 대화를 비웠습니다. 규칙과 연결은 그대로입니다.`);
+      say('');
+      return { handled: true };
+
+    case 'context': return showContext(session), { handled: true };
+
+    case 'compact': {
+      const n = session.trim();
+      say(n
+        ? `  ${mark.ok} 오래된 대화 ${n}개를 줄였습니다.`
+        : `  ${c.gray('줄일 만큼 쌓이지 않았습니다.')}`);
+      say('');
+      return { handled: true };
+    }
+
+    case 'model': return await switchModel(session, ctx), { handled: true };
+
+    case 'think': {
+      if (!THINK_LEVELS.includes(arg)) {
+        say(`  ${c.gray('지금')} ${c.bold(session.think)}   ${c.gray('고를 수 있는 값:')} ${THINK_LEVELS.join(' · ')}`);
+        say(`  ${c.gray('예')} /think high`);
+        say('');
+        return { handled: true };
+      }
+      session.think = arg;
+      say(`  ${mark.ok} 추론 강도 ${c.bold(arg)}`);
+      if (!session.conn.think && arg !== 'off') {
+        say(`     ${c.yellow('이 연결은 모델 층 조절이 안 먹습니다.')} ${c.gray('루프 층(도구 호출 상한)으로만 조절됩니다.')}`);
+      }
+      say('');
+      return { handled: true };
+    }
+
+    case 'mode': {
+      if (!MODES[arg]) {
+        say(`  ${c.gray('지금')} ${c.bold(session.mode)}`);
+        for (const [k, v] of Object.entries(MODES)) say(`    ${c.cyan(pad(k, 9))} ${c.gray(v)}`);
+        say('');
+        return { handled: true };
+      }
+      session.mode = arg;
+      say(`  ${mark.ok} 실행 모드 ${c.bold(arg)} ${c.gray('— ' + MODES[arg])}`);
+      say('');
+      return { handled: true };
+    }
+
+    case 'undo': {
+      const n = Math.max(1, parseInt(arg, 10) || 1);
+      const r = ctx.history.undo(n);
+      ctx.audit.undo({ turns: r.turns, files: r.restored.length });
+      if (!r.restored.length) {
+        say(`  ${c.gray('되돌릴 것이 없습니다.')}`);
+      } else {
+        say(`  ${mark.ok} ${r.turns}개 턴, 파일 ${r.restored.length}개를 되돌렸습니다.`);
+        for (const f of r.restored) say(`    ${c.gray(ctx.scope.show(f.path))}  ${c.gray(f.how)}`);
+      }
+      say('');
+      return { handled: true };
+    }
+
+    case 'tools': {
+      rule('도구', 70);
+      for (const [n, t] of Object.entries(TOOLS)) {
+        say(`  ${c.cyan(pad(n, 8))} ${c.gray(t.schema.description)}`);
+      }
+      say('');
+      return { handled: true };
+    }
+
+    case 'cost': {
+      const mins = ((Date.now() - session.startedAt) / 60000).toFixed(1);
+      rule('이번 세션', 70);
+      say(`  ${c.gray(pad('모델 호출', 14))} ${session.usage.calls}회`);
+      say(`  ${c.gray(pad('입력 토큰', 14))} ${session.usage.in.toLocaleString()}`);
+      say(`  ${c.gray(pad('출력 토큰', 14))} ${session.usage.out.toLocaleString()}`);
+      say(`  ${c.gray(pad('도구 시간', 14))} ${(session.usage.ms / 1000).toFixed(1)}초`);
+      say(`  ${c.gray(pad('경과', 14))} ${mins}분`);
+      say('');
+      return { handled: true };
+    }
+
+    case 'status': {
+      const k = session.conn;
+      rule('연결', 70);
+      say(`  ${c.gray(pad('규격', 10))} ${k.kind === 'ollama' ? 'Ollama' : 'OpenAI 호환'}`);
+      say(`  ${c.gray(pad('주소', 10))} ${k.base}`);
+      say(`  ${c.gray(pad('모델', 10))} ${k.model}`);
+      say(`  ${c.gray(pad('작업 폴더', 10))} ${session.root}`);
+      say(`  ${c.gray(pad('규칙', 10))} ${session.rules ? session.rules.name : '없음 (/init 으로 만들 수 있습니다)'}`);
+      const caps = [
+        k.tools ? c.green('도구') : c.red('도구'),
+        k.streaming ? c.green('스트림') : c.gray('스트림'),
+        k.json ? c.green('스키마') : c.gray('스키마'),
+        k.think ? c.green('추론') : c.gray('추론'),
+      ].join(c.gray(' · '));
+      say(`  ${c.gray(pad('지원', 10))} ${caps}`);
+      say('');
+      return { handled: true };
+    }
+
+    case 'init': {
+      const p = join(session.root, 'DEEL.md');
+      if (existsSync(p)) {
+        say(`  ${mark.warn} 이미 있습니다: ${c.cyan('DEEL.md')}`);
+        say('');
+        return { handled: true };
+      }
+      writeFileSync(p, INIT_TEMPLATE, 'utf8');
+      session.rules = { name: 'DEEL.md', text: INIT_TEMPLATE };
+      say(`  ${mark.ok} ${c.cyan('DEEL.md')} 를 만들었습니다. 이 폴더의 규칙을 여기에 적으면 매번 읽습니다.`);
+      say('');
+      return { handled: true };
+    }
+
+    case 'skills': return showSkills(session, arg), { handled: true };
+
+    default: {
+      // 이 PC 에서 찾은 슬래시 명령인지 본다. 있으면 그 내용을 모델에게 보낸다.
+      const found = (session.commands ?? []).find((x) => x.name === raw)
+        ?? (session.commands ?? []).find((x) => x.name.toLowerCase() === name)
+        ?? (session.commands ?? []).find((x) => x.name.split(':').pop() === name);
+      if (found) {
+        const { text, error } = loadCommand(found, arg);
+        if (error) { say(`  ${c.red('명령을 읽지 못했습니다')} ${error}`); say(''); return { handled: true }; }
+        say(`  ${c.cyan('⌘')} ${found.name} ${c.gray(found.source)}`);
+        return { handled: false, text };
+      }
+      const near = (session.commands ?? [])
+        .filter((x) => x.name.includes(name) || name.includes(x.name.split(':').pop()))
+        .slice(0, 5).map((x) => '/' + x.name);
+      say(`  ${c.red('모르는 명령')} /${name}`);
+      if (near.length) say(`  ${c.gray('비슷한 것:')} ${near.join('  ')}`);
+      say(`  ${c.gray('/help 로 목록을,  /skills 로 스킬을 봅니다.')}`);
+      say('');
+      return { handled: true };
+    }
+  }
+}
+
+function showSkills(session, arg) {
+  const all = session.skills ?? [];
+  if (!all.length) {
+    say('');
+    say(`  ${c.gray('이 PC 에서 찾은 스킬이 없습니다.')}`);
+    say(`  ${c.gray('찾는 자리: ./.deel/skills  ./.claude/skills  ~/.claude/skills  ~/.claude/plugins')}`);
+    say('');
+    return;
+  }
+
+  const q = arg.trim();
+  if (q === 'all') {
+    all.forEach((s) => { s.enabled = true; });
+    session.maxSkillsListed = Math.min(all.length, 200);
+    say(`  ${mark.ok} 전부 올립니다 (${session.listedSkills().length}개). ${c.yellow('컨텍스트를 많이 먹습니다 — /context 로 확인하세요.')}`);
+    say('');
+    return;
+  }
+  if (q === 'off') {
+    all.forEach((s) => { s.enabled = false; });
+    say(`  ${mark.ok} 스킬을 모두 내렸습니다.`);
+    say('');
+    return;
+  }
+  if (q.startsWith('on ')) {
+    const term = q.slice(3).trim().toLowerCase();
+    let n = 0;
+    for (const s of all) {
+      s.enabled = s.name.toLowerCase().includes(term) || s.description.toLowerCase().includes(term);
+      if (s.enabled) n++;
+    }
+    say(`  ${mark.ok} "${term}" 에 걸리는 ${n}개만 올립니다.`);
+    say('');
+    return;
+  }
+
+  const hits = q
+    ? all.filter((s) => s.name.toLowerCase().includes(q.toLowerCase()) || s.description.toLowerCase().includes(q.toLowerCase()))
+    : session.listedSkills();
+
+  say('');
+  rule(q ? `스킬 검색: ${q}` : '지금 올라간 스킬', 74);
+  for (const s of hits.slice(0, 30)) {
+    const tag = s.enabled ? c.green('●') : c.gray('○');
+    say(`  ${tag} ${c.cyan(pad(s.name, 32))} ${c.gray(s.description.slice(0, 60))}`);
+  }
+  if (hits.length > 30) say(`  ${c.gray(`… 그 밖에 ${hits.length - 30}개`)}`);
+  say('');
+
+  const bySource = { project: 0, user: 0, plugin: 0 };
+  for (const s of all) bySource[s.source] = (bySource[s.source] ?? 0) + 1;
+  say(`  ${c.gray('전체')} ${all.length}개  ${c.gray('(프로젝트')} ${bySource.project} ${c.gray('· 사용자')} ${bySource.user} ${c.gray('· 플러그인')} ${bySource.plugin}${c.gray(')')}`);
+  say(`  ${c.gray('프롬프트에 올라간 것')} ${session.listedSkills().length}개 ${c.gray(`(상한 ${session.maxSkillsListed})`)}`);
+  if ((session.plugins ?? []).length) {
+    say(`  ${c.gray('플러그인')} ${session.plugins.filter((p) => p.skills > 0).map((p) => p.name).slice(0, 8).join(', ')}`);
+  }
+  say('');
+  say(`  ${c.gray('/skills <검색어>     찾아보기')}`);
+  say(`  ${c.gray('/skills on <검색어>  걸리는 것만 올리기')}`);
+  say(`  ${c.gray('/skills all | off    전부 올리기 | 내리기')}`);
+  say('');
+}
+
+function help() {
+  say('');
+  rule('명령', 70);
+  for (const [n, m] of Object.entries(COMMANDS)) {
+    if (n === 'quit') continue;
+    say(`  ${c.cyan(pad('/' + n + (m.arg ? ' ' + m.arg : ''), 22))} ${c.gray(m.desc)}`);
+  }
+  say('');
+  say(`  ${c.gray('그 밖의 입력은 모델에게 보냅니다. 빈 줄에서 Ctrl+C 로 끝냅니다.')}`);
+  say('');
+}
+
+function showContext(session) {
+  const b = session.breakdown();
+  say('');
+  rule('컨텍스트', 70);
+  say(`  ${c.bold(session.conn.model)} ${c.gray('·')} ${b.total.toLocaleString()} 토큰`);
+  say('');
+  say(`  ${bar(b.used, b.total, 32)}  ${b.used.toLocaleString()} / ${b.total.toLocaleString()}  ${c.gray(`${Math.round((b.used / b.total) * 100)}%`)}`);
+  say('');
+  for (const r of b.rows) {
+    if (!r.n) continue;
+    say(`  ${c.gray(pad(r.label, 26))} ${pad(r.n.toLocaleString(), 8, 'right')}`);
+  }
+  say(`  ${c.gray('─'.repeat(35))}`);
+  say(`  ${c.gray(pad('남음', 26))} ${pad(b.left.toLocaleString(), 8, 'right')}`);
+  say('');
+  say(`  ${c.gray('/compact 대화 줄이기   /clear 통째로 비우기')}`);
+  say(`  ${c.gray('숫자는 추정입니다 — 정확한 토크나이저를 쓰지 않습니다.')}`);
+  say('');
+}
+
+async function switchModel(session, ctx) {
+  const cfg = load();
+  if (cfg.profiles.length <= 1 && !cfg.profiles.length) {
+    say(`  ${c.gray('저장된 연결이 없습니다.')} ${c.cyan('deel setup')}`);
+    say('');
+    return;
+  }
+  const items = cfg.profiles.map((p) => ({
+    label: `${pad(p.name, 18)} ${c.gray(p.model)}`,
+    note: p.id === cfg.active ? '지금' : '',
+  }));
+  const i = await pick('연결 고르기', items, {
+    def: cfg.profiles.findIndex((p) => p.id === cfg.active),
+    ask: ctx?.ask,
+  });
+  const p = cfg.profiles[i];
+  cfg.active = p.id;
+  save(cfg);
+  Object.assign(session.conn, {
+    kind: p.kind, base: p.baseUrl, auth: p.auth, key: resolveKey(p), model: p.model,
+    ctx: p.ctx, streaming: p.streaming, tools: p.tools, json: p.json, think: p.think,
+  });
+  say(`  ${mark.ok} ${c.bold(p.name)} ${c.gray(p.model)} 로 바꿨습니다. 대화는 이어집니다.`);
+  say('');
+}
+
+const INIT_TEMPLATE = `# DEEL.md
+
+이 폴더에서 일할 때 지킬 규칙을 적습니다. deel 가 매번 읽습니다.
+
+## 이 프로젝트
+
+- 무엇을 하는 프로젝트인지 두세 줄
+
+## 명령
+
+- 빌드:
+- 시험:
+- 실행:
+
+## 규칙
+
+- 고치기 전에 관련 파일을 먼저 읽는다
+- (프로젝트에 맞는 규칙을 적으세요)
+`;