deel-local-cli 0.5.0 → 0.9.0

package/src/commands.js

@@ -1,13 +1,20 @@
 // 슬래시 명령. 이름은 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 { c, say, rule, pad, bar, mark, width, clip } from './ui/ansi.js';
+import { compact } from './agent/compact.js';
+import { allowEndpoint } from './safety/network.js';
 import { pick } from './ui/prompt.js';
-import { load, save, resolveKey } from './config.js';
+import { load, save, resolveKey, upsert } from './config.js';
 import { TOOLS } from './tools/index.js';
-import { loadCommand } from './skills/discover.js';
-
-const THINK_LEVELS = ['off', 'low', 'medium', 'high', 'max'];
+import { loadCommand, discover } from './skills/discover.js';
+import { install, list, remove, pack } from './plugins/manage.js';
+import { spin } from './ui/spinner.js';
+import { PROFILES, LEVELS as THINK_LEVELS, normalizeProfile, table as effortTable } from './agent/effort.js';
+import { scanLocal, toProfiles } from './backend/scan.js';
+import { list as listSessions } from './agent/store.js';
+import { MODES as WORK_MODES, ORDER as WORK_ORDER, DEFAULT as WORK_DEFAULT, normalize as normWork, get as getWork, canWrite } from './agent/modes.js';
+import { LEVELS, ORDER as LEVEL_ORDER, DEFAULT as LEVEL_DEFAULT, normalize as normLevel, shows as levelShows } from './ui/level.js';
 const MODES = {
   auto: '자율 — 전부 알아서. 되돌리기가 안전망',
   confirm: '확인 — 되돌릴 수 없는 것만 물어봄',
@@ -18,29 +25,67 @@ export const COMMANDS = {
   help:    { desc: '명령 목록' },
   clear:   { desc: '대화 비우기' },
   context: { desc: '컨텍스트 사용량 보기' },
+  ctx:     { desc: '컨텍스트 길이 — 모델에 맞춰 다시 재거나 직접 지정', arg: '[auto|숫자|640k]' },
   compact: { desc: '오래된 대화 줄이기' },
-  model:   { desc: '모델·연결 바꾸기' },
+  model:   { desc: '연결·모델 바꾸기 (이름 일부 · list · models)', arg: '[이름|list|models]' },
   think:   { desc: '추론 강도 (off/low/medium/high/max)', arg: '<수준>' },
-  mode:    { desc: '실행 모드 (auto/confirm/strict)', arg: '<모드>' },
+  mode:    { desc: '승인 정책 — 얼마나 물어보나 (auto/confirm/strict)', arg: '<모드>' },
+  work:    { desc: '작업 모드 — 무슨 일을 하는 중인가 (종합이면 저절로)', arg: '[모드]' },
+  // 이름이 /mode auto 와 겹쳐 보이므로 설명에서 못을 박는다.
+  // /mode auto 는 '얼마나 물어보나', /auto 는 '무슨 일을 하는 중인가' 다.
+  auto:    { desc: '작업 모드 → 종합 (요청에 따라 저절로 옮겨 감. /mode 와 다름)' },
+  code:    { desc: '작업 모드 → 코드 (고치고 만든다)' },
+  plan:    { desc: '작업 모드 → 계획 (먼저 계획만)' },
+  architect:{ desc: '작업 모드 → 설계 (구조를 짠다)' },
+  debug:   { desc: '작업 모드 → 디버그 (원인을 찾는다)' },
+  ask:     { desc: '작업 모드 → 묻기 (설명만)' },
+  orchestrator: { desc: '작업 모드 → 총괄 (큰 일을 쪼개서)' },
   undo:    { desc: '직전 작업 되돌리기', arg: '[턴수]' },
   tools:   { desc: '쓸 수 있는 도구 보기' },
   skills:  { desc: '스킬 보기·검색·골라 올리기', arg: '[검색어|all|off]' },
+  plugin:  { desc: '플러그인 목록·설치·삭제·반입묶음', arg: '[install|remove|pack]' },
   cost:    { desc: '이번 세션 사용량' },
   status:  { desc: '연결 상태' },
+  scan:    { desc: '이 PC 의 로컬 모델 서버 훑기', arg: '[save]' },
+  sessions:{ desc: '이 폴더의 지난 대화 목록' },
+  level:   { desc: '사용자 수준 (쉬움/개발자)', arg: '[수준]' },
   init:    { desc: 'DEEL.md 규칙 파일 만들기' },
   exit:    { desc: '끝내기' },
   quit:    { desc: '끝내기' },
 };
 
+/**
+ * 이 줄이 명령이 아니라 '경로' 인가.
+ *
+ * 슬래시로 시작한다고 다 명령은 아니다. `/usr/local/bin` 이나 `/mnt/d/일감`
+ * 같은 것을 치면 그동안은 통째로 명령으로 먹혀서 "모르는 명령" 만 나오고
+ * 모델에게 닿지도 않았다. 경로를 아예 못 적는 셈이었다.
+ *
+ * 가르는 기준은 간단하다 — 명령 이름에는 슬래시가 없다.
+ * 플러그인 명령도 `/플러그인:이름` 이라 콜론을 쓰지 슬래시를 안 쓴다.
+ * 그러니 첫 낱말 안에 슬래시가 또 있으면 그건 경로다.
+ */
+function 경로처럼보이나(line) {
+  const 첫낱말 = line.slice(1).split(/\s+/)[0] ?? '';
+  if (첫낱말.includes('/') || 첫낱말.includes('\\')) return true;
+  // `/tmp` 처럼 슬래시가 하나뿐이어도, 실제로 있는 자리면 경로로 본다.
+  if (첫낱말 && !COMMANDS[첫낱말.toLowerCase()]) {
+    try { if (existsSync(line.slice(1).trim())) return true; } catch { /* 못 보면 아닌 걸로 */ }
+  }
+  return false;
+}
+
 // 반환: { handled, exit? }  handled=false 면 모델에게 보낸다.
 export async function handle(line, session, ctx) {
   if (!line.startsWith('/')) return { handled: false };
+  if (경로처럼보이나(line)) 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 'help': return help(session), { handled: true };
+    case 'level': return showLevel(session, arg), { handled: true };
     case 'exit':
     case 'quit': return { handled: true, exit: true };
 
@@ -52,30 +97,50 @@ export async function handle(line, session, ctx) {
 
     case 'context': return showContext(session), { handled: true };
 
+    case 'ctx': return await ctxLength(session, arg), { handled: true };
+
     case 'compact': {
-      const n = session.trim();
-      say(n
-        ? `  ${mark.ok} 오래된 대화 ${n}개를 줄였습니다.`
-        : `  ${c.gray('줄일 만큼 쌓이지 않았습니다.')}`);
+      const s = spin('앞선 대화를 요약해 접는 중…');
+      const r = await compact(session);
+      if (!r.ok) {
+        s.stop(`  ${c.gray(r.why ?? '접지 못했습니다.')}`);
+        say('');
+        return { handled: true };
+      }
+      const 줄인 = r.before - r.after;
+      s.stop(`  ${mark.ok} 대화 ${r.folded}개를 요약으로 접었습니다.`);
+      say(`     ${c.gray(r.before.toLocaleString())} ${c.gray('→')} ${c.white(r.after.toLocaleString())} ${c.gray('토큰')}  ${c.green(`${Math.round((줄인 / Math.max(1, r.before)) * 100)}% 줄어듦`)}`);
+      if (r.fallback) say(`     ${c.yellow('요약을 못 받아 그냥 줄였습니다.')}`);
+      else if (r.summary) {
+        say('');
+        for (const line of r.summary.split('\n').slice(0, 14)) say(`     ${c.gray(clip(line, 76))}`);
+      }
       say('');
       return { handled: true };
     }
 
-    case 'model': return await switchModel(session, ctx), { handled: true };
+    case 'model': return await switchModel(session, ctx, arg), { handled: true };
 
     case 'think': {
+      const asProfile = normalizeProfile(arg);
+      if (asProfile) {
+        session.effort = asProfile;
+        session.effortSet = true;   // 사용자가 직접 정했다 — 작업 모드보다 우선한다
+        say(`  ${mark.ok} 배분 ${c.bold(PROFILES[asProfile].name)} ${c.gray('— ' + PROFILES[asProfile].desc)}`);
+        showThink(session);
+        return { handled: true };
+      }
       if (!THINK_LEVELS.includes(arg)) {
-        say(`  ${c.gray('지금')} ${c.bold(session.think)}   ${c.gray('고를 수 있는 값:')} ${THINK_LEVELS.join(' · ')}`);
-        say(`  ${c.gray('예')} /think high`);
-        say('');
+        showThink(session);
         return { handled: true };
       }
       session.think = arg;
+      session.thinkSet = true;      // 사용자가 직접 정했다 — 작업 모드보다 우선한다
       say(`  ${mark.ok} 추론 강도 ${c.bold(arg)}`);
       if (!session.conn.think && arg !== 'off') {
-        say(`     ${c.yellow('이 연결은 모델 층 조절이 안 먹습니다.')} ${c.gray('루프 층(도구 호출 상한)으로만 조절됩니다.')}`);
+        say(`     ${c.yellow('이 연결은 모델 층 조절이 적용되지 않습니다.')} ${c.gray('루프 층(도구 호출 상한)으로만 조절됩니다.')}`);
       }
-      say('');
+      showThink(session);
       return { handled: true };
     }
 
@@ -146,6 +211,84 @@ export async function handle(line, session, ctx) {
       return { handled: true };
     }
 
+    case 'work':
+    case 'auto':
+    case 'code': case 'plan': case 'architect':
+    case 'debug': case 'ask': case 'orchestrator': {
+      const 원하는 = name === 'work' ? normWork(arg) : name;
+      if (name === 'work' && !원하는) { showWork(session); return { handled: true }; }
+      const 골라진 = normWork(원하는);
+      if (!골라진) {
+        say(`  ${mark.warn} 그런 모드는 없습니다: ${c.white(arg)}`);
+        say(`  ${c.gray('쓸 수 있는 것:')} ${WORK_ORDER.map((k) => c.cyan(WORK_MODES[k].name)).join(c.gray(' · '))}`);
+        say('');
+        return { handled: true };
+      }
+      session.work = 골라진;
+      // 사람이 직접 골랐다. 저절로 골라 둔 것이 있으면 지운다 —
+      // 안 지우면 이번 한마디는 여전히 옛 모드로 돌아 "왜 안 바뀌지" 가 된다.
+      session.routed = null;
+      const w = getWork(골라진);
+      say('');
+      say(`  ${c.hcyan(w.glyph)} ${c.bold(w.name)} ${c.gray('(' + w.en + ')')}  ${c.gray(w.hint)}`);
+      say(`  ${c.gray('도구')}    ${canWrite(골라진) ? c.yellow('읽기 + 파일 바꾸기') : c.green('읽기만 — 파일을 못 바꿉니다')}`);
+      say(`  ${c.gray('생각')}    ${c.white(w.think ?? session.think)}${c.gray('·')}${c.magenta(w.effort)}   ${c.gray('최대 ' + w.steps + '걸음')}`);
+      if (골라진 === 'auto') {
+        say(`  ${c.gray('앞으로는 한마디마다 알맞은 모드로 저절로 옮겨 갑니다.')}`);
+      } else {
+        say(`  ${c.gray('직접 고르셨으므로 저절로 바뀌지 않습니다. 다시 맡기려면')} ${c.cyan('/work 종합')}`);
+      }
+      say('');
+      return { handled: true };
+    }
+
+    case 'scan': {
+      const s2 = spin('이 PC 의 로컬 서버를 찾는 중…');
+      const found = await scanLocal({ timeout: 1500 });
+      s2.stop(`  ${found.length ? mark.ok : mark.warn} ${found.length}곳 찾음`);
+      if (!found.length) {
+        say(`  ${c.gray('떠 있는 로컬 서버가 없습니다. 다른 포트라면')} ${c.cyan('deel scan --ports ...')}`);
+        say('');
+        return { handled: true };
+      }
+      for (const f of found) {
+        say(`  ${c.hcyan('◆')} ${c.bold(pad(f.runtime, 12))}${c.gray(pad(`${f.host}:${f.port}`, 22))}${c.gray(`모델 ${f.models.length}개`)}`);
+        for (const m of f.models.slice(0, 6)) say(`      ${c.gray('·')} ${clip(m.id, 44)}`);
+        if (f.models.length > 6) say(`      ${c.gray(`… 그 밖에 ${f.models.length - 6}개`)}`);
+      }
+      say('');
+      if (arg === 'save') {
+        const cfg2 = load();
+        const ps = toProfiles(found, cfg2.profiles);
+        for (const x of ps) upsert(cfg2, x);
+        save(cfg2);
+        say(`  ${mark.ok} ${ps.length}개 등록했습니다. ${c.cyan('/model')} 로 고르세요.`);
+      } else {
+        say(`  ${c.gray('등록하려면')} ${c.cyan('/scan save')}   ${c.gray('고르려면')} ${c.cyan('/model')}`);
+      }
+      say('');
+      return { handled: true };
+    }
+
+    case 'sessions': {
+      const rows = listSessions(session.root, { limit: 12 });
+      rule('이 폴더의 지난 대화', 70);
+      if (!rows.length) {
+        say(`  ${c.gray('아직 없습니다. 지금 이 대화가 첫 번째입니다.')}`);
+        say('');
+        return { handled: true };
+      }
+      for (const [i, r] of rows.entries()) {
+        say(`  ${i === 0 ? c.hgreen('●') : c.gray('·')} ${c.bold(pad(r.id, 17))}${c.gray(pad(`${r.turns}턴`, 6, 'right'))}  ${c.gray(clip(r.model, 22))}`);
+        say(`      ${c.gray(clip(r.first, 66))}`);
+      }
+      say('');
+      say(`  ${c.gray('이어하려면 나갔다가')} ${c.cyan('deel --continue')} ${c.gray('또는')} ${c.cyan(`deel --resume ${rows[0].id}`)}`);
+      say(`  ${c.gray('지금 대화는 나가지 않아도 계속 저장되고 있습니다.')}`);
+      say('');
+      return { handled: true };
+    }
+
     case 'init': {
       const p = join(session.root, 'DEEL.md');
       if (existsSync(p)) {
@@ -162,6 +305,9 @@ export async function handle(line, session, ctx) {
 
     case 'skills': return showSkills(session, arg), { handled: true };
 
+    case 'plugin':
+    case 'plugins': return await doPlugin(session, arg), { handled: true };
+
     default: {
       // 이 PC 에서 찾은 슬래시 명령인지 본다. 있으면 그 내용을 모델에게 보낸다.
       const found = (session.commands ?? []).find((x) => x.name === raw)
@@ -185,6 +331,97 @@ export async function handle(line, session, ctx) {
   }
 }
 
+async function doPlugin(session, arg) {
+  const [sub = '', ...rest] = arg.trim().split(/\s+/);
+  const param = rest.join(' ').trim();
+
+  // 설치·삭제 뒤에는 다시 훑어 이번 대화에 바로 반영한다.
+  const rescan = () => {
+    const f = discover(session.root);
+    session.skills = f.skills;
+    session.commands = f.commands;
+    session.plugins = f.plugins;
+    return f;
+  };
+
+  if (sub === 'install' || sub === 'add') {
+    if (!param) {
+      say(`  ${c.gray('예')} /plugin install affaan-m/ECC`);
+      say(`  ${c.gray('  ')} /plugin install owner/repo#가지이름`);
+      say('');
+      return;
+    }
+    say('');
+    const s = spin(`${param} 받는 중...`);
+    const r = await install(param, { onStep: (m) => {} });
+    if (r.error) {
+      s.stop(`  ${mark.no} ${c.red(r.error.split('\n')[0])}`);
+      for (const line of r.error.split('\n').slice(1)) say(`     ${c.gray(line.trim())}`);
+      say(`     ${c.gray('오프라인이면 zip 을 ~/.deel/plugins/ 에 직접 풀면 됩니다.')}`);
+      say('');
+      return;
+    }
+    s.stop(`  ${mark.ok} ${c.bold(r.name)}${r.version ? ' ' + c.gray(r.version) : ''} ${c.gray(`(${r.license ?? '라이선스 미상'})`)}`);
+    say(`     ${c.gray('스킬')} ${r.skills}개  ${c.gray('명령')} ${r.commands}개  ${c.gray(`· ${r.how} 로 받음`)}`);
+    if (r.hooks) say(`     ${mark.warn} ${c.yellow(`실행 스크립트 ${r.hooks}개는 쓰지 않습니다`)} ${c.gray('(hook 미지원 · 반입 심사 대상)')}`);
+    const f = rescan();
+    say(`     ${c.gray(`이제 스킬 ${f.skills.length}개 · 명령 ${f.commands.length}개`)}`);
+    say('');
+    return;
+  }
+
+  if (sub === 'remove' || sub === 'rm' || sub === 'uninstall') {
+    if (!param) { say(`  ${c.gray('예')} /plugin remove ecc`); say(''); return; }
+    const r = remove(param);
+    if (r.error) { say(`  ${mark.no} ${c.red(r.error)}`); say(''); return; }
+    const f = rescan();
+    say(`  ${mark.ok} ${c.bold(r.removed)} 지웠습니다. ${c.gray(`이제 스킬 ${f.skills.length}개`)}`);
+    say('');
+    return;
+  }
+
+  if (sub === 'pack') {
+    const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    const out = param || join(session.root, `deel-plugins-${stamp}.zip`);
+    const r = pack(out, { only: null });
+    if (r.error) { say(`  ${mark.no} ${c.red(r.error)}`); say(''); return; }
+    say('');
+    say(`  ${mark.ok} ${c.cyan(r.out)}`);
+    say(`     ${c.gray('플러그인')} ${r.plugins.length}개 ${c.gray('· 파일')} ${r.files}개 ${c.gray('·')} ${(r.bytes / 1024).toFixed(0)}KB`);
+    if (r.skipped) say(`     ${c.gray(`실행 스크립트 ${r.skipped}개는 뺐습니다`)}`);
+    say('');
+    rule('담긴 것', 74);
+    for (const p of r.plugins) {
+      say(`  ${c.cyan(pad(p.name, 22))} ${c.gray(pad(p.version || '-', 9))} ${c.gray(pad(p.license || '미상', 14))} ${c.gray(`스킬 ${p.skills} · 명령 ${p.commands}`)}`);
+    }
+    say('');
+    say(`  ${c.gray('오프라인 기기의')} ~/.deel/plugins/ ${c.gray('에 풀면 바로 인식됩니다. 설치 명령은 필요 없습니다.')}`);
+    say(`  ${c.gray('묶음 안에 라이선스 표가 담긴 사용안내.txt 가 함께 들어 있습니다.')}`);
+    say('');
+    return;
+  }
+
+  // 인자 없으면 목록
+  const items = list();
+  if (!items.length) {
+    say('');
+    say(`  ${c.gray('설치된 플러그인이 없습니다.')}`);
+    say(`  ${c.gray('받기')}  /plugin install owner/repo`);
+    say(`  ${c.gray('직접')}  ~/.deel/plugins/ 에 폴더를 풀어 넣어도 됩니다`);
+    say('');
+    return;
+  }
+  say('');
+  rule('플러그인', 74);
+  for (const p of items) {
+    say(`  ${c.cyan(pad(p.name, 22))} ${c.gray(pad(p.version || '-', 9))} ${c.gray(pad(p.license || '미상', 14))} ${c.gray(`스킬 ${p.skills} · 명령 ${p.commands}`)}`);
+    say(`    ${c.gray(p.from)}`);
+  }
+  say('');
+  say(`  ${c.gray('/plugin install <owner/repo>   /plugin remove <이름>   /plugin pack [파일]')}`);
+  say('');
+}
+
 function showSkills(session, arg) {
   const all = session.skills ?? [];
   if (!all.length) {
@@ -199,7 +436,7 @@ function showSkills(session, arg) {
   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(`  ${mark.ok} 전부 올립니다 (${session.listedSkills().length}개). ${c.yellow('컨텍스트를 많이 차지합니다 — /context 로 확인하세요.')}`);
     say('');
     return;
   }
@@ -248,18 +485,88 @@ function showSkills(session, arg) {
   say('');
 }
 
-function help() {
+function help(session) {
+  const level = session?.level ?? LEVEL_DEFAULT;
+  const 쉬움 = !levelShows(level, '__전부__');   // 개발자면 show 가 null 이라 전부 참
   say('');
-  rule('명령', 70);
+  rule(쉬움 ? '명령 (자주 쓰는 것)' : '명령', 70);
+  let 감춘수 = 0;
   for (const [n, m] of Object.entries(COMMANDS)) {
     if (n === 'quit') continue;
+    if (!levelShows(level, n)) { 감춘수++; continue; }
     say(`  ${c.cyan(pad('/' + n + (m.arg ? ' ' + m.arg : ''), 22))} ${c.gray(m.desc)}`);
   }
   say('');
+  // 감춘 것은 '못 쓰는 것' 이 아니다. 그 말을 분명히 해 둔다.
+  if (감춘수) {
+    say(`  ${c.gray(`이 밖에 ${감춘수}개가 더 있습니다 — 직접 입력하면 그대로 실행됩니다.`)}`);
+    say(`  ${c.gray('전부 보려면')} ${c.cyan('/level 개발자')}`);
+    say('');
+  }
   say(`  ${c.gray('그 밖의 입력은 모델에게 보냅니다. 빈 줄에서 Ctrl+C 로 끝냅니다.')}`);
   say('');
 }
 
+// /level — 수준 보기·바꾸기. 설정 파일에 남겨 다음에도 그대로 쓴다.
+function showLevel(session, arg) {
+  if (!arg) {
+    rule('사용자 수준', 70);
+    for (const k of LEVEL_ORDER) {
+      const lv = LEVELS[k];
+      const 지금 = k === (normLevel(session.level) ?? LEVEL_DEFAULT);
+      say(`  ${지금 ? c.hgreen('●') : c.gray('·')} ${지금 ? c.bold(c.white(pad(lv.name, 10))) : c.gray(pad(lv.name, 10))}${c.gray(lv.hint)}`);
+    }
+    say('');
+    say(`  ${c.gray('안전 장치는 두 수준이 똑같습니다 — 되돌리기·작업 범위·위험 명령 차단.')}`);
+    say(`  ${c.gray('수준은 무엇을 보여줄지만 정합니다.')}`);
+    say('');
+    say(`  ${c.gray('바꾸려면')} ${c.cyan('/level 쉬움')} ${c.gray('또는')} ${c.cyan('/level 개발자')}`);
+    say('');
+    return;
+  }
+  const 골라진 = normLevel(arg);
+  if (!골라진) {
+    say(`  ${mark.warn} 그런 수준은 없습니다: ${c.white(arg)}  ${c.gray('(쉬움 · 개발자)')}`);
+    say('');
+    return;
+  }
+  session.level = 골라진;
+  try {
+    const cfg = load();
+    cfg.level = 골라진;
+    save(cfg);
+  } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+  const lv = LEVELS[골라진];
+  say('');
+  say(`  ${mark.ok} ${c.bold(lv.name)} ${c.gray('— ' + lv.hint)}`);
+  say(`  ${c.gray('안전 장치는 그대로입니다.')}`);
+  say('');
+}
+
+// 추론 강도는 값 하나가 아니라 '단계별 배분' 이다. 그 배분을 눈에 보이게 그린다.
+function showThink(session) {
+  const b = session.breakdown();
+  const t = effortTable(session.think, session.effort, { ctx: b.total, used: b.used, max: session.conn.maxTokens ?? null });
+  say('');
+  rule('추론 강도', 70);
+  say(`  기준 ${c.bold(session.think)}   배분 ${c.bold(t.name)}   ${c.gray(t.desc)}`);
+  say(`  ${c.gray('상한은 이 모델 기준으로 계산합니다 — 컨텍스트')} ${c.white(t.ctx.toLocaleString())}${c.gray(', 지금 찬 양')} ${c.white(t.used.toLocaleString())}`);
+  say('');
+  say(`  ${c.gray(pad('단계', 12) + pad('강도', 10) + pad('출력상한', 10) + '언제')}`);
+  for (const r of t.rows) {
+    const 화살 = r.moved > 0 ? c.yellow('↑') : r.moved < 0 ? c.cyan('↓') : c.gray('·');
+    say(`  ${pad(r.label, 12)}${화살} ${pad(r.level, 8)}${pad(r.cap.toLocaleString(), 10, 'right')}  ${c.gray(r.why)}`);
+  }
+  say('');
+  say(`  ${c.gray('강도')}  ${THINK_LEVELS.join(' · ')}            ${c.gray('예')} ${c.cyan('/think high')}`);
+  say(`  ${c.gray('배분')}  ${Object.entries(PROFILES).map(([k, v]) => `${k}(${v.name})`).join(' · ')}   ${c.gray('예')} ${c.cyan('/think save')}`);
+  if (!session.conn.think && session.think !== 'off') {
+    say('');
+    say(`  ${c.yellow('이 연결은 모델 층 강도 조절이 적용되지 않습니다.')} ${c.gray('출력 상한만 단계별로 적용됩니다.')}`);
+  }
+  say('');
+}
+
 function showContext(session) {
   const b = session.breakdown();
   say('');
@@ -280,32 +587,333 @@ function showContext(session) {
   say('');
 }
 
-async function switchModel(session, ctx) {
+/**
+ * 컨텍스트 길이를 보고·다시 재고·직접 지정한다.
+ *
+ *   /ctx            지금 값과 어디서 나온 값인지
+ *   /ctx auto       서버에 다시 물어 모델에 맞춘다
+ *   /ctx 655360     직접 지정 (640k · 128k · 1m 도 받는다 — k 는 1024)
+ *
+ * 왜 필요한가: 이 숫자 하나가 프로그램 전체 크기를 정한다. 서버가 안 알려주면
+ * 32,768 로 깔고 앉는데, 요즘 로컬 모델은 262,144 · 655,360 이 흔하다.
+ * 그 상태로 쓰면 모델이 가진 것의 5% 만 쓰는 셈이다.
+ *
+ * 고른 값은 프로필에 남긴다 — 다음에 켤 때도 그대로여야 한다.
+ */
+async function ctxLength(session, arg = '') {
+  const { probeCtx, parseSize, fmtSize } = await import('./backend/ctxsize.js');
+  const 말 = String(arg ?? '').trim().toLowerCase();
+  const 지금 = session.conn.ctx ?? 0;
+
+  const 남기기 = (값, 어디서) => {
+    session.conn.ctx = 값;
+    const cfg = load();
+    const prof = cfg.profiles.find((p) => p.id === cfg.active) ?? cfg.profiles[0];
+    if (prof) { prof.ctx = 값; save(cfg); }
+    const b = session.breakdown();
+    say(`  ${mark.ok} 컨텍스트 ${c.bold(값.toLocaleString())} 토큰 ${c.gray(`(${fmtSize(값)}) — ${어디서}`)}`);
+    say(`     ${c.gray('지금 찬 양')} ${c.white(b.used.toLocaleString())} ${c.gray('· 남음')} ${c.white(b.left.toLocaleString())}`);
+    if (prof) say(`     ${c.gray('프로필에 저장했습니다. 다음에 켤 때도 이 값입니다.')}`);
+    say('');
+  };
+
+  // 0) 답 길이 상한 — 컨텍스트와는 다른 축이다.
+  //
+  // 컨텍스트가 655k 여도 '한 번에 뱉을 수 있는 답' 은 대개 훨씬 작다(기본 16,384).
+  // 모델 한계보다 큰 max_tokens 를 보내면 아예 거부하는 게이트웨이가 있어서 그렇게 뒀다.
+  // 큰 모델을 쓰면 여기서 올릴 수 있다.
+  if (/^(out|답|출력)\b/.test(말)) {
+    const 값 = parseSize(말.replace(/^(out|답|출력)\s*/, ''));
+    const cfg = load();
+    const prof = cfg.profiles.find((p) => p.id === cfg.active) ?? cfg.profiles[0];
+    if (!값) {
+      say(`  ${c.gray('한 번에 받을 답 길이 상한')}  ${c.white((session.conn.maxTokens ?? 16384).toLocaleString())} ${c.gray('토큰')}`);
+      say(`  ${c.gray('올리려면')} ${c.cyan('/ctx out 32k')} ${c.gray('— 모델이 못 내는 값을 넣으면 서버가 거절합니다.')}`);
+      say('');
+      return;
+    }
+    session.conn.maxTokens = 값;
+    if (prof) { prof.maxTokens = 값; try { save(cfg); } catch {} }
+    say(`  ${mark.ok} 답 길이 상한 ${c.bold(값.toLocaleString())} 토큰 ${c.gray('— 컨텍스트와는 다른 축입니다')}`);
+    say('');
+    return;
+  }
+
+  // 1) 직접 지정
+  if (말 && 말 !== 'auto' && 말 !== '자동' && 말 !== '다시') {
+    const 값 = parseSize(말);
+    if (!값) {
+      say(`  ${mark.no} 숫자를 못 읽었습니다: ${c.white(arg)}`);
+      say(`     ${c.gray('이렇게 쓰세요 —')} ${c.cyan('/ctx 655360')}  ${c.cyan('/ctx 640k')}  ${c.cyan('/ctx 128k')}  ${c.cyan('/ctx auto')}`);
+      say(`     ${c.gray('k 는 1024 입니다. 655,360 은 640k 이지 655k 가 아닙니다 — 헷갈리면 그냥 숫자로 쓰세요.')}`);
+      say('');
+      return;
+    }
+    남기기(값, '직접 지정');
+    say(`  ${c.gray('서버가 실제로 올려 둔 길이보다 크게 잡으면 긴 대화에서 거절당합니다.')}`);
+    say(`  ${c.gray('서버 쪽에서 올린 다음 맞추는 게 안전합니다 —')} ${c.cyan('/ctx auto')} ${c.gray('로 다시 잽니다.')}`);
+    say('');
+    return;
+  }
+
+  // 2) 다시 재기
+  if (말) {
+    const s = spin('모델에 걸린 길이를 서버에 묻는 중…');
+    let r;
+    try { r = await probeCtx(session.conn); }
+    catch (err) { s.stop(`  ${mark.no} 못 물어봤습니다 — ${c.gray(String(err?.message ?? err))}`); say(''); return; }
+    s.stop('');
+    if (!r.value) {
+      say(`  ${mark.warn} 서버가 컨텍스트 길이를 안 알려줍니다.`);
+      for (const t of r.tried) say(`     ${c.gray(pad(t.label, 20))} ${c.gray(t.ok ? '응답함(값 없음)' : `${t.status || '연결 실패'}`)}`);
+      say(`     ${c.gray('직접 넣어 주세요 —')} ${c.cyan('/ctx 655360')}`);
+      say('');
+      return;
+    }
+    남기기(r.value, `${r.source ?? '서버'}에서 읽음`);
+    if (r.max && r.loaded && r.max > r.loaded) {
+      say(`  ${c.yellow('이 모델은')} ${c.bold(r.max.toLocaleString())} ${c.yellow('까지 되는데 지금')} ${c.bold(r.loaded.toLocaleString())} ${c.yellow('로 올려 두셨습니다.')}`);
+      say(`     ${c.gray('서버(LM Studio 등)에서 컨텍스트를 더 올려 다시 올린 뒤')} ${c.cyan('/ctx auto')} ${c.gray('를 하시면 그만큼 씁니다.')}`);
+      say('');
+    }
+    return;
+  }
+
+  // 3) 그냥 보기
+  const b = session.breakdown();
+  say('');
+  rule('컨텍스트 길이', 70);
+  say(`  ${c.bold(session.conn.model)}`);
+  say(`  ${c.gray('지금 잡은 길이')}   ${c.white(지금.toLocaleString())} ${c.gray('토큰 (' + fmtSize(지금) + ')')}`);
+  say(`  ${c.gray('찬 양')}           ${c.white(b.used.toLocaleString())} ${c.gray('· 남음 ' + b.left.toLocaleString())}`);
+  say('');
+  say(`  ${c.gray('이 값 하나가 프로그램 전체 크기를 정합니다 — 한 번에 읽힐 수 있는 파일 수,')}`);
+  say(`  ${c.gray('대화가 접히는 시점, 한 번에 쓸 수 있는 답 길이가 모두 여기서 나옵니다.')}`);
+  say('');
+  say(`  ${c.cyan('/ctx auto')}      ${c.gray('서버에 다시 물어 모델에 맞춥니다')}`);
+  say(`  ${c.cyan('/ctx 655360')}    ${c.gray('직접 지정 (640k · 128k · 1m 도 됩니다 — k 는 1024)')}`);
+  say(`  ${c.cyan('/ctx out 32k')}   ${c.gray('한 번에 받을 답 길이 상한 (지금 ' + (session.conn.maxTokens ?? 16384).toLocaleString() + ') — 다른 축입니다')}`);
+  say('');
+}
+
+/** 지금 연결을 이 프로필로 갈아끼운다. 대화는 그대로 둔다. */
+function 연결적용(session, p) {
+  Object.assign(session.conn, {
+    kind: p.kind, base: p.baseUrl, auth: p.auth, key: resolveKey(p), model: p.model,
+    ctx: p.ctx, maxTokens: p.maxTokens ?? null,
+    streaming: p.streaming, tools: p.tools, json: p.json, think: p.think,
+  });
+  // 자물쇠도 같이 옮긴다. 이걸 빼먹으면 옛 주소가 열린 채로 남고 새 주소는 막혀
+  // 다음 한마디에서 바로 "허용되지 않은 주소" 가 난다.
+  allowEndpoint(p.baseUrl);
+}
+
+/**
+ * 지금 붙어 있는 서버가 내주는 모델 목록.
+ *
+ * 저장된 프로필에는 등록할 때 고른 모델 하나만 있다. 그런데 서버 한 대가
+ * 모델을 여럿 내주는 경우가 대부분이다 — 특히 프록시나 게이트웨이가 그렇다.
+ * 그래서 서버에 직접 물어본다. 자리를 새로 여는 게 아니라 이미 열린 자리다.
+ */
+async function 서버모델들(conn) {
+  const { req, headersFor } = await import('./backend/http.js');
+  if (conn.kind === 'ollama') {
+    const r = await req(`${conn.base.replace(/\/v1\/?$/, '')}/api/tags`, { timeout: 4000 });
+    return (r.json?.models ?? []).map((m) => m.name ?? m.model).filter(Boolean);
+  }
+  const r = await req(`${conn.base.replace(/\/$/, '')}/models`, {
+    headers: headersFor(conn.auth ?? 'none', conn.key), timeout: 4000,
+  });
+  if (!r.ok) return null;
+  const list = r.json?.data ?? r.json?.models ?? [];
+  return Array.isArray(list)
+    ? list.map((m) => (typeof m === 'string' ? m : m.id ?? m.name ?? m.model)).filter(Boolean)
+    : null;
+}
+
+/**
+ * /model — 연결·모델 바꾸기.
+ *
+ *   /model            골라 바꾸기 (연결 목록 + '이 서버의 다른 모델')
+ *   /model <이름>     바로 바꾸기. 연결 이름이든 모델 이름이든 일부만 쳐도 된다
+ *   /model list       무엇이 등록돼 있는지만 보기
+ *   /model models     지금 서버가 내주는 모델을 물어보기
+ */
+async function switchModel(session, ctx, arg = '') {
   const cfg = load();
-  if (cfg.profiles.length <= 1 && !cfg.profiles.length) {
-    say(`  ${c.gray('저장된 연결이 없습니다.')} ${c.cyan('deel setup')}`);
+  if (!cfg.profiles.length) {
+    say(`  ${c.gray('저장된 연결이 없습니다.')} ${c.cyan('deel setup')} ${c.gray('또는')} ${c.cyan('deel scan --save')}`);
+    say('');
+    return;
+  }
+  const 말 = arg.trim();
+
+  if (말 === 'list' || 말 === '목록') return 연결목록(cfg, session);
+  if (말 === 'models' || 말 === '모델') return await 서버모델고르기(session, ctx, cfg);
+
+  // 이름으로 바로 바꾸기 — 메뉴를 안 거친다.
+  if (말) {
+    const 찾은 = 이름으로찾기(cfg.profiles, 말);
+    if (찾은.length === 1) return 골라적용(session, cfg, 찾은[0]);
+    if (찾은.length > 1) {
+      say(`  ${mark.warn} ${c.white(말)} ${c.gray('에 맞는 것이 여럿입니다.')}`);
+      for (const p of 찾은.slice(0, 12)) say(`    ${c.cyan(p.name)}  ${c.gray(p.model)}`);
+      say('');
+      return;
+    }
+    // 등록된 것에 없으면, 지금 서버가 내주는 모델 중에 있는지 본다.
+    const 있는것 = await 서버모델들(session.conn);
+    const 맞는것 = (있는것 ?? []).filter((m) => m.toLowerCase().includes(말.toLowerCase()));
+    if (맞는것.length === 1) return await 모델만바꾸기(session, cfg, 맞는것[0]);
+    if (맞는것.length > 1) {
+      say(`  ${mark.warn} ${c.white(말)} ${c.gray('에 맞는 모델이 여럿입니다.')}`);
+      for (const m of 맞는것.slice(0, 12)) say(`    ${c.cyan(m)}`);
+      say('');
+      return;
+    }
+    say(`  ${mark.warn} ${c.white(말)} ${c.gray('에 맞는 연결도 모델도 없습니다.')}`);
+    say(`  ${c.gray('무엇이 있는지 보려면')} ${c.cyan('/model list')}${c.gray(', 서버에 물어보려면')} ${c.cyan('/model models')}`);
     say('');
     return;
   }
+
+  // 인자 없이 — 골라 바꾸기. 물어볼 수 없는 자리면 목록만 보여준다.
+  if (!ctx?.ask) return 연결목록(cfg, session);
+
   const items = cfg.profiles.map((p) => ({
-    label: `${pad(p.name, 18)} ${c.gray(p.model)}`,
+    label: `${pad(p.name, 22)} ${c.gray(p.model)}`,
     note: p.id === cfg.active ? '지금' : '',
   }));
-  const i = await pick('연결 고르기', items, {
-    def: cfg.profiles.findIndex((p) => p.id === cfg.active),
+  items.push({ label: c.cyan('이 서버의 다른 모델 고르기'), note: '서버에 물어봅니다' });
+
+  const i = await pick('연결·모델 고르기', items, {
+    def: Math.max(0, cfg.profiles.findIndex((p) => p.id === cfg.active)),
     ask: ctx?.ask,
   });
-  const p = cfg.profiles[i];
+  if (i === cfg.profiles.length) return await 서버모델고르기(session, ctx, cfg);
+  return 골라적용(session, cfg, cfg.profiles[i]);
+}
+
+function 이름으로찾기(profiles, 말) {
+  const q = 말.toLowerCase();
+  const 정확 = profiles.filter((p) => p.name.toLowerCase() === q || p.model.toLowerCase() === q || p.id.toLowerCase() === q);
+  if (정확.length) return 정확;
+  return profiles.filter((p) => `${p.name} ${p.model} ${p.id}`.toLowerCase().includes(q));
+}
+
+function 골라적용(session, cfg, p) {
   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,
-  });
+  try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 바뀐다 */ }
+  연결적용(session, p);
   say(`  ${mark.ok} ${c.bold(p.name)} ${c.gray(p.model)} 로 바꿨습니다. 대화는 이어집니다.`);
   say('');
 }
 
+/**
+ * 같은 서버에서 모델만 바꾼다.
+ *
+ * 등록된 연결이 아니어도 된다 — 서버가 내준다면 쓸 수 있어야 한다.
+ * 다음에도 쓰도록 프로필로 남겨 둔다. 그래야 /model 목록에서 다시 보인다.
+ */
+async function 모델만바꾸기(session, cfg, 모델) {
+  const 지금 = cfg.profiles.find((p) => p.id === cfg.active) ?? cfg.profiles[0];
+  const 이미 = cfg.profiles.find((p) => p.baseUrl === session.conn.base && p.model === 모델);
+  const p = 이미 ?? {
+    ...지금,
+    id: `${(지금?.id ?? 'conn').replace(/-[^-]*$/, '')}-${String(모델).replace(/[^a-zA-Z0-9._-]+/g, '-')}`.slice(0, 60).toLowerCase(),
+    name: `${(지금?.name ?? '연결').split(' · ')[0]} · ${모델}`,
+    baseUrl: session.conn.base,
+    model: 모델,
+    // 컨텍스트 길이는 물려받지 않는다. 모델마다 다르다 —
+    // 32k 짜리에서 655k 짜리로 옮겼는데 32k 로 깔고 앉으면 새 모델의 5% 만 쓴다.
+    // 반대로 큰 데서 작은 데로 옮기면 긴 대화에서 서버가 거절한다. 아래에서 다시 잰다.
+    ctx: null,
+  };
+  if (!이미) { try { save(upsert(cfg, p)); } catch { /* 못 남겨도 이번 세션에는 바뀐다 */ } }
+  else { cfg.active = p.id; try { save(cfg); } catch {} }
+  연결적용(session, p);
+  say(`  ${mark.ok} 모델을 ${c.bold(모델)} 로 바꿨습니다. ${c.gray('서버는 그대로입니다.')}`);
+  await 길이맞추기(session, cfg, p);
+  say('');
+}
+
+/**
+ * 바뀐 모델에 맞춰 컨텍스트 길이를 다시 잰다.
+ *
+ * 모델을 바꾸는 순간은 이미 서버와 이야기하는 중이라 한 번 더 물어봐도 티가 안 난다.
+ * 여기서 안 재면 새 모델을 옛 모델의 길이로 쓰게 된다 — 화면에는 아무 표시도 안 나고
+ * 그냥 조용히 작아진다. 그런 고장이 가장 늦게 발견된다.
+ */
+async function 길이맞추기(session, cfg, prof) {
+  const { probeCtx, fmtSize, 기본값 } = await import('./backend/ctxsize.js');
+  let r = null;
+  try { r = await probeCtx(session.conn, { timeout: 8000 }); } catch { /* 못 물어보면 아래에서 기본값 */ }
+  const 값 = r?.value ?? prof.ctx ?? 기본값;
+  session.conn.ctx = 값;
+  if (prof) {
+    prof.ctx = 값;
+    try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+  }
+  say(`     ${c.gray('컨텍스트')} ${c.white(값.toLocaleString())} ${c.gray('토큰 (' + fmtSize(값) + ') — ' + (r?.source ? r.source + '에서 읽음' : '서버가 안 알려줘 기본값'))}`);
+  if (r?.max && r?.loaded && r.max > r.loaded) {
+    say(`     ${c.yellow('이 모델은 ' + r.max.toLocaleString() + ' 까지 됩니다.')} ${c.gray('서버에서 더 올린 뒤')} ${c.cyan('/ctx auto')}`);
+  } else if (!r?.value) {
+    say(`     ${c.gray('맞지 않으면')} ${c.cyan('/ctx 655360')} ${c.gray('처럼 직접 지정하세요.')}`);
+  }
+}
+
+function 연결목록(cfg, session) {
+  rule('등록된 연결', 70);
+  for (const p of cfg.profiles) {
+    const 지금 = p.id === cfg.active;
+    say(`  ${지금 ? c.hgreen('●') : c.gray('·')} ${지금 ? c.bold(c.white(pad(p.name, 26))) : pad(p.name, 26)}${c.gray(p.model)}`);
+    say(`      ${c.gray(p.baseUrl)}`);
+  }
+  say('');
+  say(`  ${c.gray('바꾸려면')} ${c.cyan('/model <이름 일부>')}${c.gray(' — 연결 이름이든 모델 이름이든 됩니다.')}`);
+  say(`  ${c.gray('이 서버가 내주는 다른 모델을 보려면')} ${c.cyan('/model models')}`);
+  say('');
+}
+
+async function 서버모델고르기(session, ctx, cfg) {
+  const s = spin('서버에 모델 목록을 물어보는 중…');
+  let 있는것;
+  try { 있는것 = await 서버모델들(session.conn); } catch { 있는것 = null; }
+  s.stop('');
+  if (!있는것 || !있는것.length) {
+    say(`  ${mark.warn} 이 서버는 모델 목록을 내주지 않습니다.`);
+    say(`  ${c.gray('목록이 없는 게이트웨이도 있습니다. 그때는')} ${c.cyan('deel setup')} ${c.gray('에서 모델 이름을 직접 넣으세요.')}`);
+    say('');
+    return;
+  }
+  // 물어볼 수 없는 자리면 목록만 보여주고 끝낸다.
+  //
+  // 여기서 그냥 pick 을 부르면 표준입력을 붙잡고 영영 안 끝난다.
+  // 파이프로 넣거나 검사에서 돌릴 때가 그렇다 — 멈춘 것처럼 보이고 끊는 수밖에 없다.
+  if (!ctx?.ask) {
+    rule(`이 서버의 모델 (${있는것.length}개)`, 70);
+    for (const m of 있는것) say(`  ${m === session.conn.model ? c.hgreen('●') : c.gray('·')} ${m === session.conn.model ? c.bold(m) : m}`);
+    say('');
+    say(`  ${c.gray('바꾸려면')} ${c.cyan('/model <이름 일부>')}`);
+    say('');
+    return;
+  }
+
+  const i = await pick(`이 서버의 모델 (${있는것.length}개)`, 있는것.map((m) => ({
+    label: m, note: m === session.conn.model ? '지금' : '',
+  })), {
+    def: Math.max(0, 있는것.indexOf(session.conn.model)),
+    ask: ctx.ask,
+  });
+  const 고른것 = 있는것[i];
+  if (고른것 === session.conn.model) {
+    say(`  ${c.gray('그대로 둡니다.')}`);
+    say('');
+    return;
+  }
+  await 모델만바꾸기(session, cfg, 고른것);
+}
+
 const INIT_TEMPLATE = `# DEEL.md
 
 이 폴더에서 일할 때 지킬 규칙을 적습니다. deel 가 매번 읽습니다.
@@ -325,3 +933,20 @@ const INIT_TEMPLATE = `# DEEL.md
 - 고치기 전에 관련 파일을 먼저 읽는다
 - (프로젝트에 맞는 규칙을 적으세요)
 `;
+
+// /work 를 인자 없이 부르면 지금 모드와 고를 수 있는 것들을 보여 준다.
+function showWork(session) {
+  rule('작업 모드', 70);
+  for (const k of WORK_ORDER) {
+    const w = WORK_MODES[k];
+    const 지금 = k === (normWork(session.work) ?? WORK_DEFAULT);
+    const 표 = 지금 ? c.hgreen('●') : c.gray('·');
+    const 이름 = 지금 ? c.bold(c.white(pad(w.name, 8))) : c.gray(pad(w.name, 8));
+    say(`  ${표} ${c.hcyan(w.glyph)} ${이름}${c.gray(pad(w.en, 14))}${c.gray(w.hint)}`);
+    say(`        ${canWrite(k) ? c.gray('파일 바꿈') : c.green('읽기만')}${c.gray('  ·  생각 ' + (w.think ?? '그대로') + '·' + w.effort + '  ·  최대 ' + w.steps + '걸음')}`);
+  }
+  say('');
+  say(`  ${c.gray('바꾸려면')} ${c.cyan('/plan')} ${c.cyan('/code')} ${c.cyan('/debug')} ${c.gray('…  또는')} ${c.cyan('Shift+Tab')} ${c.gray('으로 차례로')}`);
+  say(`  ${c.gray('이건 승인 정책(')}${c.cyan('/mode')}${c.gray(')과 다른 축입니다 — 무엇을 하느냐 / 얼마나 물어보냐.')}`);
+  say('');
+}