deel-local-cli 0.8.0 → 0.9.0

package/src/agent/modes.js

@@ -18,6 +18,36 @@ const 계획 = ['TodoWrite'];
 const 쓰기 = ['Write', 'Edit', 'Bash'];
 
 export const MODES = {
+  // 처음에는 여기서 시작한다.
+  //
+  // 무슨 일을 시킬지 미리 정해 두고 켜는 사람은 드물다. 그래서 기본은 '종합' 이고,
+  // 한마디를 할 때마다 그 말이 무슨 일인지 보고 알맞은 모드로 저절로 옮겨 간다
+  // (agent/route.js). 애매하면 안 옮기고 여기 그대로 둔다.
+  //
+  // 사용자가 /plan 처럼 직접 고르면 저절로 옮기는 것은 멈춘다. 사람이 고른 것을
+  // 뒤집지 않는다. 다시 맡기려면 /work 종합 이다.
+  auto: {
+    id: 'auto',
+    name: '종합',
+    en: 'Auto',
+    glyph: '◎',
+    hint: '요청에 따라 알맞은 모드로',
+    tools: [...읽기, ...계획, ...쓰기],
+    effort: 'save',
+    think: null,
+    steps: 24,
+    say: [
+      '지금은 **종합** 모드다. 무슨 일이 올지 정해져 있지 않다.',
+      '',
+      '- 시키는 일이 무엇인지 먼저 가늠하고, 그에 맞는 방식으로 해라.',
+      '  고치는 일이면 읽고 나서 고치고, 원인을 찾는 일이면 확인부터 하고,',
+      '  설명하는 일이면 근거를 파일에서 대라.',
+      '- 큰 일이면 TodoWrite 로 쪼개 적고 하나씩 해라.',
+      '- 확인할 수 있는 것은 확인해라. 확인 못 한 것을 됐다고 하지 마라.',
+      '- 시키지 않은 일을 벌이지 마라.',
+    ].join('\n'),
+  },
+
   code: {
     id: 'code',
     name: '코드',
@@ -28,7 +58,17 @@ export const MODES = {
     effort: 'save',            // 첫 판단만 세게, 이어가기는 얕게
     think: null,               // 사용자가 정한 값을 그대로 쓴다
     steps: 24,
-    say: '코드를 읽고 고칩니다. 고치기 전에 반드시 먼저 읽으세요.',
+    say: [
+      "지금 하는 일은 **구현**이다. 아래 순서를 지켜라.",
+      "",
+      "1. 고칠 파일을 먼저 Read 로 읽는다. 안 읽고 고치려 하면 도구가 거절한다.",
+      "2. 주변 코드의 관례를 따른다 — 이름 짓는 법, 오류 다루는 법, 주석 밀도까지.",
+      "   새 관례를 들여오지 마라. 이 코드가 이미 하고 있는 대로 한다.",
+      "3. 한 번에 하나씩 고친다. 여러 파일에 흩뿌리지 마라.",
+      "4. 고친 뒤에는 확인할 방법이 있으면 실제로 돌려 본다 (검사·빌드·실행).",
+      "   확인 못 했으면 \"확인 못 했다\" 고 말한다. 됐다고 하지 마라.",
+      "5. 끝나면 무엇을 왜 바꿨는지 한두 줄로 말한다. 코드를 통째로 붙여넣지 마라.",
+    ].join('\n'),
   },
 
   architect: {
@@ -41,9 +81,23 @@ export const MODES = {
     effort: 'deep',
     think: 'high',
     steps: 20,
-    say: '구조와 설계를 다룹니다. 파일을 바꾸는 도구는 주어지지 않았습니다. '
-       + '지금 코드를 충분히 읽고, 어디를 어떻게 바꿀지 근거와 함께 제안하세요. '
-       + '고르는 이유와 버리는 이유를 같이 적으세요.',
+    say: [
+      "지금 하는 일은 **설계**다. 파일을 바꾸는 도구는 주어지지 않았다.",
+      "",
+      "먼저 읽어라. 지금 구조를 모르면 설계가 아니라 상상이다.",
+      "  - 관련된 파일을 Glob/Grep 으로 찾고 Read 로 실제로 읽는다",
+      "  - 무엇이 무엇에 기대고 있는지(의존 방향)를 파악한다",
+      "",
+      "그 다음 이 차례로 답한다.",
+      "  1. 지금 구조 — 파일과 역할, 경계가 어디인지 (경로:줄 로 짚어라)",
+      "  2. 무엇이 문제인가 — 왜 지금 모양으로는 안 되는지",
+      "  3. 선택지 2~3개 — 각각 무엇을 얻고 무엇을 잃는지, 손이 얼마나 가는지",
+      "  4. 추천 하나와 그 이유, 버린 것을 왜 버렸는지",
+      "  5. 영향받는 파일 목록",
+      "",
+      "이 코드가 이미 쓰는 관례 안에서 답을 찾아라. 새 틀을 들여오는 것은 마지막",
+      "수단이고, 그때는 왜 기존 관례로 안 되는지를 먼저 밝혀라.",
+    ].join('\n'),
   },
 
   ask: {
@@ -56,8 +110,14 @@ export const MODES = {
     effort: 'even',
     think: 'low',
     steps: 8,
-    say: '질문에 답하고 설명합니다. 시키지 않은 일을 벌이지 마세요. '
-       + '코드를 읽어 근거를 대되, 고치라는 말이 없으면 고칠 것을 제안하지 마세요.',
+    say: [
+      "지금 하는 일은 **설명**이다. 아무것도 바꾸지 않는다.",
+      "",
+      "- 근거를 파일에서 대라. 경로와 줄 번호를 같이 적어라 (src/a.js:42).",
+      "- 모르면 모른다고 하라. 그럴듯한 답을 지어내지 마라.",
+      "- 짧게, 물어본 것에만 답하라.",
+      "- 고치라는 말이 없으면 고칠 것을 제안하지 마라. 시키지 않은 일을 벌이지 마라.",
+    ].join('\n'),
   },
 
   debug: {
@@ -70,9 +130,20 @@ export const MODES = {
     effort: 'deep',
     think: 'high',
     steps: 32,               // 원인 찾기는 왔다 갔다 하므로 여유를 준다
-    say: '무엇이 잘못됐는지 찾습니다. 고치기 전에 원인을 먼저 밝히세요. '
-       + '짐작으로 고치지 말고, 확인할 수 있는 것을 확인하세요 — 로그를 보고, '
-       + '작은 것을 실제로 돌려 보고, 무엇이 사실인지 말한 다음 고치세요.',
+    say: [
+      "지금 하는 일은 **원인 찾기**다. 짐작으로 고치지 마라.",
+      "",
+      "이 순서를 지켜라.",
+      "  1. 증상을 한 문장으로 다시 적는다 — 무엇을 했을 때 무엇이 일어나는가.",
+      "  2. 재현 방법을 확보한다. 없으면 만든다. 재현 못 하면 고쳤는지도 알 수 없다.",
+      "  3. 가설을 2~3개 세운다. 각각 \"이게 맞다면 무엇이 보여야 하는가\" 를 같이 적는다.",
+      "  4. 하나씩 실제로 확인한다 — 로그를 보고, 작게 돌려 보고, 값을 찍어 본다.",
+      "     확인한 것만 사실이다. 확인 안 한 것은 아직 가설이다.",
+      "  5. 원인을 짚을 때는 증거를 같이 댄다. \"아마\" 로 시작하는 원인은 원인이 아니다.",
+      "  6. 고친 뒤 2번의 재현 절차로 다시 확인한다. 안 고쳐졌으면 3번으로 돌아간다.",
+      "",
+      "한 번에 여러 곳을 고치지 마라. 무엇이 고쳤는지 알 수 없게 된다.",
+    ].join('\n'),
   },
 
   plan: {
@@ -85,9 +156,26 @@ export const MODES = {
     effort: 'deep',
     think: 'high',
     steps: 16,
-    say: '먼저 계획만 세웁니다. 파일을 바꾸는 도구는 주어지지 않았습니다. '
-       + '무엇을 어떤 순서로 할지, 위험이 무엇인지 적고 멈추세요. '
-       + '사용자가 승인하면 그때 코드 모드로 바뀝니다.',
+    say: [
+      "지금 하는 일은 **계획 세우기**다. 파일을 바꾸는 도구는 주어지지 않았다.",
+      "코드를 고치려 들지 마라. 계획을 내고 멈춘다.",
+      "",
+      "먼저 확인하라 — 지금 무엇이 어떻게 되어 있는지 모르면 계획이 아니라 희망이다.",
+      "  Glob/Grep 으로 관련 파일을 찾고, Read 로 실제로 읽어라.",
+      "",
+      "그 다음 이 차례로 적어라.",
+      "  1. 목표 — 무엇이 끝나면 다 된 것인가 (확인할 수 있는 문장으로)",
+      "  2. 지금 상태 — 관련된 파일과 지금 동작 (경로:줄 로 짚어라)",
+      "  3. 바꿀 것 — 파일별로 무엇을 왜",
+      "  4. 순서 — 단계별로. 각 단계는 따로 확인할 수 있는 크기로 쪼개라",
+      "  5. 위험 — 무엇이 깨질 수 있고, 깨지면 어떻게 되돌리는가",
+      "  6. 확인 방법 — 무엇을 돌려 보면 됐는지 알 수 있는가",
+      "",
+      "단계는 TodoWrite 로도 적어라. 승인 뒤 그대로 이어서 하게 된다.",
+      "모르는 것이 있으면 지어내지 말고 \"이건 확인이 필요하다\" 고 적어라.",
+      "",
+      "마지막에 \"이대로 진행할까요?\" 로 끝내라. 승인을 받으면 /code 로 바꿔 실행한다.",
+    ].join('\n'),
   },
 
   orchestrator: {
@@ -100,14 +188,24 @@ export const MODES = {
     effort: 'save',
     think: null,
     steps: 40,               // 여러 갈래를 끝까지 끌고 가야 한다
-    say: '여러 단계가 걸리는 일을 끝까지 끌고 갑니다. '
-       + '먼저 TodoWrite 로 할 일을 쪼개 적고, 하나씩 끝낼 때마다 갱신하세요. '
-       + '한 번에 하나만 진행 중으로 두세요. 다 끝나면 무엇을 했는지 요약하세요.',
+    say: [
+      "지금 하는 일은 **큰 일을 끝까지 끌고 가기**다.",
+      "",
+      "  1. 시작하자마자 TodoWrite 로 전체를 단계로 쪼개 적어라. 머릿속에만 두지 마라.",
+      "     단계는 각각 따로 확인할 수 있는 크기여야 한다.",
+      "  2. 한 번에 하나만 진행 중으로 둬라. 끝나면 바로 표시하고 다음으로 넘어가라.",
+      "  3. 각 단계 끝에서 확인하라. 확인 없이 넘어가면 어디서 어긋났는지 못 찾는다.",
+      "  4. 막히면 멈추고 무엇에 막혔는지 보고하라. 우회로를 몰래 타지 마라.",
+      "  5. 계획이 틀린 것을 알게 되면 목록을 고쳐라. 틀린 계획을 끝까지 밀지 마라.",
+      "",
+      "다 끝나면 무엇을 했는지, 무엇을 못 했는지 같이 요약하라.",
+      "못 한 것을 빼고 요약하지 마라.",
+    ].join('\n'),
   },
 };
 
-export const ORDER = ['code', 'plan', 'architect', 'debug', 'ask', 'orchestrator'];
-export const DEFAULT = 'code';
+export const ORDER = ['auto', 'code', 'plan', 'architect', 'debug', 'ask', 'orchestrator'];
+export const DEFAULT = 'auto';
 
 /** 이름을 관대하게 받는다. 한글·영문·줄임말 다 통한다. */
 export function normalize(v) {
@@ -115,6 +213,7 @@ export function normalize(v) {
   if (!s) return null;
   if (MODES[s]) return s;
   const 별명 = {
+    '종합': 'auto', '자동': 'auto', '기본': 'auto', 'auto': 'auto', '맡김': 'auto',
     '코드': 'code', 'c': 'code',
     '계획': 'plan', '플랜': 'plan', 'p': 'plan',
     '설계': 'architect', '아키': 'architect', 'arch': 'architect', 'a': 'architect',

package/src/agent/route.js

@@ -0,0 +1,156 @@
+// 사용자가 무엇을 시켰는지 보고 알맞은 작업 모드를 고른다.
+//
+// 왜 규칙으로 하나:
+//   모델에게 "이건 무슨 일이냐" 고 한 번 더 물을 수도 있다. 그런데 그러면
+//   한마디 할 때마다 왕복이 하나 늘고, 작은 로컬 모델은 이런 분류를 잘 못한다.
+//   느려지고 틀리기까지 하면 자동으로 하는 의미가 없다.
+//
+//   그래서 낱말로 고른다. 대신 두 가지를 지킨다.
+//     1) 애매하면 안 바꾼다. 종합 모드에 그대로 둔다.
+//        잘못 바꾸는 것보다 안 바꾸는 편이 낫다 — 특히 읽기 전용 모드로
+//        잘못 보내면 사용자는 "왜 파일을 안 고쳐?" 하고 막힌다.
+//     2) 왜 그렇게 봤는지 남긴다. 화면에 그 이유가 같이 뜬다.
+//
+// 사용자가 직접 모드를 고르면 이건 아예 안 돈다. 사람이 고른 것을 뒤집지 않는다.
+
+// 낱말과 점수. 큰 점수일수록 그 모드라는 증거가 강하다는 뜻이다.
+//
+// 한국어를 먼저 두되 영어도 같이 본다 — 오류 메시지를 그대로 붙여넣는 일이 흔하다.
+const 표 = {
+  debug: [
+    // 고장은 신호가 뚜렷하다. 그리고 디버그는 파일을 고칠 수 있으므로
+    // 잘못 골라도 막히지 않는다. 그래서 세게 준다.
+    [/왜\s*안\s*(되|돼|됨)/, 5], [/안\s*(되는|돼는|됩니다|되네|돼네|돼요|되요)/, 4],
+    [/작동\s*안/, 4], [/동작\s*안/, 4],
+    [/에러|오류|예외|익셉션/, 4], [/버그/, 4],
+    [/실패/, 3], [/터(져|졌|진다)/, 3], [/죽(어|었|는다|네)/, 3],
+    [/멈(춰|췄|춘다|추)/, 3], [/먹통/, 3], [/이상(해|하다|한데)/, 3],
+    [/재현/, 3], [/스택\s*트레이스|stack\s*trace|traceback/i, 4],
+    // 'TypeError' 처럼 앞에 글자가 붙어 오는 일이 훨씬 흔하다.
+    // \berror\b 로 잡으면 정작 붙여넣은 진짜 오류 메시지를 놓친다.
+    [/error/i, 3], [/\bexception\b|\bcrash|\bfail(s|ed|ing)?\b|\bbroken\b/i, 3],
+    [/고장/, 3], [/왜\s*이(래|러|렇게\s*나)/, 2],
+    [/왜\s*(못|안)/, 3], [/뭐\s*때문(이|에)/, 3],
+  ],
+
+  plan: [
+    // '먼저' 와 붙어야 계획이다. 그냥 '어떻게' 는 설명일 수도 있다.
+    [/계획/, 5], [/플랜|\bplan\b/i, 5],
+    [/먼저\s*(정리|생각|살펴|파악|검토|짜|세)/, 4],
+    [/어떤\s*순서/, 4], [/순서(를|대로)?\s*(정|짜|잡)/, 3],
+    [/단계(를|로)?\s*(나눠|쪼개|정리)/, 3],
+    [/로드맵|\broadmap\b/i, 5],
+    [/방향(을|만)?\s*(잡|정)/, 3],
+    [/하기\s*전에\s*(정리|살펴|검토)/, 3],
+    [/무엇부터|뭐부터/, 3],
+  ],
+
+  architect: [
+    [/설계/, 5], [/아키텍(처|쳐)|architecture/i, 5],
+    [/구조(를|가|는)?\s*(어떻게|바꾸|잡|짜|개선)/, 5],
+    [/어떻게\s*(나누|쪼개|짜)/, 5],
+    [/모듈(로|을)?\s*(나누|분리)/, 3],
+    [/의존(성|\s*방향)/, 3], [/레이어|계층/, 3],
+    [/어느\s*(쪽|것)이\s*(나을|좋을)/, 3], [/선택지|대안/, 3],
+    [/패턴(을|이)?\s*(쓰|적용|고르)/, 2],
+    [/\bdesign\b|\bstructure\b|\brefactor(ing)?\s*(방향|plan)/i, 3],
+  ],
+
+  ask: [
+    // 설명은 아무것도 안 바꾸는 모드라 잘못 고르면 답답해진다. 신호를 엄격히 본다.
+    [/뭐(야|예요|입니까|지)\s*\??$/m, 5], [/무엇(인가|입니까|이야)/, 5],
+    [/설명(해|좀|을)/, 5], [/알려\s*(줘|주세요|줄래)/, 3],
+    [/어떻게\s*(동작|작동|돌아가)/, 5],
+    [/무슨\s*(뜻|의미)|의미(가|는)\s*뭐/, 5],
+    [/차이(가|는|점)/, 3],
+    [/궁금/, 3], [/왜\s*이렇게\s*(만들|짰|되어)/, 3],
+    [/\bwhat\s+is\b|\bexplain\b|\bhow\s+does\b/i, 4],
+    [/읽어(만)?\s*보고\s*(설명|알려)/, 4],
+  ],
+
+  orchestrator: [
+    // 총괄의 신호는 낱말 하나가 아니라 '넓이' 다. 그래서 하나하나는 약하게 두고
+    // 여럿이 겹칠 때 문턱을 넘게 한다 — 실제로 큰 일에는 이런 말이 같이 나온다.
+    // "전체 로그 형식을 다 통일해줘" 는 '전체' 와 '통일' 이 겹쳐야 총괄이 된다.
+    [/전부|모두|싹\s*다|통째로/, 3],
+    [/전체/, 3],
+    [/하나씩/, 3],
+    [/끝까지/, 3], [/마무리까지/, 3],
+    [/여러\s*(개|군데|파일|단계|곳)/, 3],
+    [/순서대로/, 3],
+    [/통일(해|시켜|좀)|일괄/, 2],
+    [/흩어진|여기저기/, 2],
+    [/\bend[- ]?to[- ]?end\b/i, 3],
+  ],
+
+  code: [
+    [/고쳐|고쳐줘|수정(해|좀)/, 4],
+    [/만들어|추가(해|좀)|넣어(줘|주세요)/, 4],
+    [/구현(해|좀)/, 5],
+    [/바꿔(줘|주세요)?|변경(해|좀)/, 3],
+    [/지워(줘)?|삭제(해|좀)/, 3],
+    [/이름\s*바꿔|리네임|rename/i, 3],
+    [/옮겨(줘)?/, 2],
+    [/리팩터(링)?(해|좀)/, 3],
+    [/\bimplement\b|\badd\b|\bfix\b|\bwrite\b/i, 2],
+    [/써(줘|주세요)/, 3],
+  ],
+};
+
+// 이만큼은 되어야 바꾼다. 못 미치면 종합 모드 그대로 둔다.
+//
+// 읽기 전용 모드는 문턱을 높인다. 잘못 보내면 파일을 못 고쳐서 사용자가 막힌다.
+// 파일을 고칠 수 있는 모드는 잘못 골라도 일이 막히지는 않으므로 낮게 둔다.
+const 문턱 = {
+  debug: 3,
+  code: 3,
+  orchestrator: 4,
+  plan: 5,
+  architect: 5,
+  ask: 5,
+};
+
+/**
+ * 이 한마디가 무슨 일인지 고른다.
+ *
+ * @param {string} text 사용자가 친 말
+ * @returns {{ mode: string|null, score: number, why: string, 점수들: object }}
+ *          mode 가 null 이면 '모르겠다' 는 뜻이다 — 종합 모드에 그대로 둔다.
+ */
+export function route(text) {
+  const s = String(text ?? '');
+  const 점수들 = {};
+  const 근거 = {};
+
+  for (const [mode, 규칙들] of Object.entries(표)) {
+    let 합 = 0;
+    const 걸린것 = [];
+    for (const [re, 점] of 규칙들) {
+      const m = s.match(re);
+      if (!m) continue;
+      합 += 점;
+      걸린것.push(m[0].trim());
+    }
+    점수들[mode] = 합;
+    근거[mode] = 걸린것;
+  }
+
+  const 순위 = Object.entries(점수들).sort((a, b) => b[1] - a[1]);
+  const [으뜸, 점수] = 순위[0] ?? [null, 0];
+  if (!으뜸 || 점수 < (문턱[으뜸] ?? 4)) {
+    return { mode: null, score: 점수, why: '무슨 일인지 뚜렷하지 않음', 점수들 };
+  }
+
+  // 1·2등이 붙으면 고르지 않는다. 반반인 것을 억지로 정하면 절반은 틀린다.
+  const 둘째 = 순위[1]?.[1] ?? 0;
+  if (점수 - 둘째 < 2 && 둘째 >= (문턱[순위[1][0]] ?? 4)) {
+    return { mode: null, score: 점수, why: `${으뜸} 과 ${순위[1][0]} 가 비슷함`, 점수들 };
+  }
+
+  return {
+    mode: 으뜸,
+    score: 점수,
+    why: 근거[으뜸].slice(0, 2).map((x) => `'${x}'`).join(', '),
+    점수들,
+  };
+}

package/src/agent/session.js

@@ -32,6 +32,9 @@ export class Session {
     this.root = root;
     this.mode = mode;        // 승인 정책 — 얼마나 물어보나 (auto/confirm/strict)
     this.work = work ?? WORK_DEFAULT;   // 작업 모드 — 무슨 일을 하는 중인가 (modes.js)
+    // 이번 한마디에만 쓸 모드. 종합 모드일 때 요청을 보고 골라 넣는다 (agent/route.js).
+    // 기본 모드(this.work)는 안 건드린다 — 다음 한마디는 다시 처음부터 고른다.
+    this.routed = null;
     // 사용자 수준 — 화면에 무엇을 내놓을지만 정한다. 안전 장치는 안 바꾼다 (ui/level.js)
     this.level = normLevel(level) ?? LEVEL_DEFAULT;
     this.think = think;      // 기준 강도
@@ -60,12 +63,23 @@ export class Session {
     return null;
   }
 
+  /**
+   * 지금 이 순간 실제로 쓰는 작업 모드.
+   *
+   * 종합 모드에서는 한마디마다 골라 넣은 것(routed)이 있고, 그때는 그것이 답이다.
+   * 직접 고른 모드가 있으면 routed 는 비어 있으므로 기본 모드가 그대로 답이 된다.
+   * 도구·추론·프롬프트가 전부 이 값을 봐야 한다. 하나라도 빠뜨리면 어긋난다.
+   */
+  effectiveWork() {
+    return this.routed ?? this.work;
+  }
+
   systemPrompt() {
     const parts = [BASE_RULES];
     parts.push(`\n작업 폴더: ${this.root}\n이 폴더 밖의 파일은 읽지도 쓰지도 못한다.`);
 
     // 지금 무슨 일을 하는 중인지. 도구 목록도 이 모드에 맞춰 이미 걸러져 있다.
-    const w = workMode(this.work);
+    const w = workMode(this.effectiveWork());
     parts.push(`\n--- 지금 모드: ${w.name} (${w.en}) ---\n${w.say}`);
     if (this.rules) parts.push(`\n--- ${this.rules.name} (사용자 규칙, 위 원칙보다 우선) ---\n${this.rules.text}`);
     const listed = this.listedSkills();

package/src/backend/ctxsize.js

@@ -0,0 +1,174 @@
+// 모델이 한 번에 받아 줄 수 있는 길이(컨텍스트)를 서버에서 알아낸다.
+//
+// 왜 파일을 따로 뒀는가:
+//
+// 이 숫자 하나가 프로그램 전체를 좌우한다. 이게 작으면 파일을 몇 개 못 읽히고,
+// 대화가 금방 접히고, 한 번에 쓸 수 있는 답 길이도 같이 줄어든다(effort.js 가
+// 이 값에서 상한을 계산한다). 예전에는 못 알아내면 32768 로 뒀는데, 요즘
+// 로컬 모델은 262,144 · 655,360 처럼 훨씬 크다. 32k 로 깔고 앉으면 모델이
+// 가진 것의 5% 만 쓰는 셈이다.
+//
+// 문제는 서버마다 이 숫자를 다른 이름, 다른 자리에 둔다는 것이다. 그래서
+// 한 군데만 보지 않고 아는 자리를 전부 훑는다. 한 번에 다 못 찾아도
+// 부분만 찾으면 그걸 쓴다.
+//
+//   OpenAI 호환    /v1/models/{id}  또는 /v1/models 목록 안의 그 항목
+//   LM Studio      /api/v0/models   (max_context_length · loaded_context_length)
+//   llama.cpp      /props           (n_ctx)
+//   vLLM           /v1/models       (max_model_len)
+//   Ollama         /api/show        (…​.context_length)
+//
+// '올린 길이' 와 '모델 최대' 를 구분한다. LM Studio 는 모델이 655,360 까지
+// 되더라도 8,192 로 올려 둘 수 있다. 그 상태에서 655,360 을 믿고 보내면
+// 서버가 거절한다. 그래서 실제로 쓸 값은 '올린 길이' 로 잡고, '모델 최대' 는
+// 따로 알려 준다 — 사용자가 서버에서 더 올린 다음 /ctx 로 맞출 수 있게.
+import { req, headersFor } from './http.js';
+
+// 이 이름들 중 하나면 컨텍스트 길이다. 순서가 곧 우선순위다.
+const 최대이름 = [
+  'max_context_length',      // LM Studio
+  'context_window',          // 일부 게이트웨이
+  'context_length',          // llama.cpp·HF 계열
+  'max_model_len',           // vLLM
+  'max_input_tokens',        // LiteLLM·OpenRouter 계열
+  'n_ctx',                   // llama.cpp
+  'max_position_embeddings', // 모델 config 원본
+  'max_sequence_length',
+  'max_seq_len',
+];
+const 올린이름 = ['loaded_context_length', 'n_ctx', 'context_length'];
+
+// 사람이 알아볼 수 없는 값은 안 받는다. 512 미만은 오독, 1000만 초과는 단위 착각.
+const 최소 = 512;
+const 최대허용 = 10_000_000;
+
+function 성한수(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return null;
+  const i = Math.floor(n);
+  return i >= 최소 && i <= 최대허용 ? i : null;
+}
+
+/**
+ * 객체 어디에 박혀 있어도 찾는다.
+ *
+ * 서버가 { data: { meta: { config: { max_position_embeddings: 655360 } } } } 처럼
+ * 깊이 넣어 두는 일이 흔하다. 그래서 이름으로 훑는다. 다만 아무 데나 파고들면
+ * 엉뚱한 숫자를 집으므로 깊이를 5 로 막는다.
+ */
+function 파보기(obj, 이름들, depth = 0) {
+  if (!obj || typeof obj !== 'object' || depth > 5) return null;
+  for (const key of 이름들) {
+    const v = 성한수(obj[key]);
+    if (v) return v;
+  }
+  // 이름이 정확히 안 맞으면 '…context_length' 처럼 끝나는 것도 본다 (Ollama).
+  for (const [k, v] of Object.entries(obj)) {
+    if (/(^|[._])(context_length|context_window|n_ctx)$/i.test(k)) {
+      const n = 성한수(v);
+      if (n) return n;
+    }
+  }
+  for (const v of Object.values(obj)) {
+    if (v && typeof v === 'object') {
+      const found = 파보기(v, 이름들, depth + 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+// 목록 응답에서 이 모델 항목만 골라낸다.
+function 목록에서찾기(json, model) {
+  const list = json?.data ?? json?.models ?? (Array.isArray(json) ? json : []);
+  if (!Array.isArray(list)) return null;
+  return list.find((m) => (m?.id ?? m?.name ?? m?.model) === model) ?? null;
+}
+
+/**
+ * 서버에 물어 컨텍스트 길이를 알아낸다.
+ *
+ * @param {{kind:string, base:string, auth:string, key:string, model:string}} conn
+ * @returns {Promise<{value:number|null, max:number|null, loaded:number|null, source:string|null, tried:Array}>}
+ */
+export async function probeCtx(conn, { timeout = 12000 } = {}) {
+  const H = () => headersFor(conn.auth, conn.key);
+  const base = String(conn.base ?? '').replace(/\/+$/, '');
+  const origin = base.replace(/\/v\d+$/, '').replace(/\/api$/, '');
+  const model = conn.model;
+  const tried = [];
+  let max = null;
+  let loaded = null;
+  let source = null;
+
+  const 본다 = async (label, url, opts = {}) => {
+    if (max && loaded) return null;
+    try {
+      const r = await req(url, { headers: H(), timeout, ...opts });
+      tried.push({ label, url, status: r.status ?? 0, ok: !!r.ok });
+      return r.ok ? r.json : null;
+    } catch (err) {
+      tried.push({ label, url, status: 0, ok: false, why: String(err?.message ?? err) });
+      return null;
+    }
+  };
+
+  const 담기 = (json, label, { 목록 = false } = {}) => {
+    if (!json) return;
+    const 대상 = 목록 ? 목록에서찾기(json, model) : json;
+    if (!대상) return;
+    const m = 파보기(대상, 최대이름);
+    const l = 파보기(대상, 올린이름);
+    if (m && !max) { max = m; source = label; }
+    if (l && !loaded) loaded = l;
+  };
+
+  if (conn.kind === 'ollama') {
+    담기(await 본다('Ollama /api/show', `${origin}/api/show`, { method: 'POST', body: { model } }), 'Ollama 모델 정보');
+  } else {
+    // 1) 이 모델만 콕 집어 묻는다. 있으면 가장 정확하다.
+    담기(await 본다('모델 상세', `${base}/models/${encodeURIComponent(model)}`), '모델 상세');
+
+    // 2) LM Studio 는 자기 규격에만 '올린 길이' 를 준다. 이게 실제로 쓸 값이다.
+    담기(await 본다('LM Studio 상세', `${origin}/api/v0/models/${encodeURIComponent(model)}`), 'LM Studio');
+    담기(await 본다('LM Studio 목록', `${origin}/api/v0/models`), 'LM Studio', { 목록: true });
+
+    // 3) 목록 응답 안에 들어 있는 경우 (vLLM 의 max_model_len 이 여기 있다)
+    담기(await 본다('모델 목록', `${base}/models`), '모델 목록', { 목록: true });
+
+    // 4) llama.cpp 서버는 /props 로만 알려 준다.
+    const props = await 본다('llama.cpp /props', `${origin}/props`);
+    if (props) {
+      const n = 파보기(props, ['n_ctx', 'context_length']);
+      if (n) { if (!max) { max = n; source = 'llama.cpp'; } if (!loaded) loaded = n; }
+    }
+  }
+
+  // 실제로 쓸 값: 올려 둔 길이가 있으면 그것. 없으면 모델 최대.
+  const value = loaded ?? max ?? null;
+  return { value, max, loaded, source, tried };
+}
+
+/**
+ * "655360" · "655k" · "128K" · "1m" 을 숫자로. 못 읽으면 null.
+ *
+ * k/m 을 받는 이유는 단순하다 — 655360 을 손으로 치면 자릿수를 틀린다.
+ */
+export function parseSize(text) {
+  const s = String(text ?? '').trim().replace(/[,_\s]/g, '').toLowerCase();
+  const m = /^(\d+(?:\.\d+)?)([km])?$/.exec(s);
+  if (!m) return null;
+  const mult = m[2] === 'm' ? 1024 * 1024 : m[2] === 'k' ? 1024 : 1;
+  return 성한수(Number(m[1]) * mult);
+}
+
+/** 33k · 655k · 1.0M — 화면에 넣을 짧은 표기 */
+export function fmtSize(n) {
+  const v = Number(n) || 0;
+  if (v < 1000) return String(v);
+  if (v < 1024 * 1024) return Math.round(v / 1024) + 'k';
+  return (v / (1024 * 1024)).toFixed(1) + 'M';
+}
+
+/** 서버가 끝내 안 알려 줄 때 쓰는 값. 옛날 32768 보다는 요즘 기본에 가깝다. */
+export const 기본값 = 32768;

package/src/backend/http.js

@@ -11,6 +11,29 @@ export const AUTH_STYLES = [
   { id: 'none', label: '인증 없음', apply: () => {} },
 ];
 
+/**
+ * 열어 둔 연결을 닫는다. 프로그램을 끝내기 직전에 부른다.
+ *
+ * fetch 는 연결을 재사용하려고 소켓을 살려 둔다(keep-alive). 그래서 할 일이
+ * 끝나도 프로세스가 저절로 안 끝난다. 예전에는 그걸 process.exit() 으로
+ * 잘라 냈는데, 윈도우에서 닫는 중인 핸들을 두고 끊으면 libuv 가 abort 한다.
+ *
+ *   Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), src\win\async.c
+ *
+ * 실제로 `deel scan` 이 결과를 다 찍고 나서 이렇게 죽었다. 화면에는 정상으로
+ * 보이는데 종료코드는 3221226505(0xC0000409) 였다.
+ *
+ * 그래서 잘라 내는 대신 닫는다. 이 자리는 Node 내부 이름이라 없을 수도 있으므로,
+ * 없으면 조용히 넘어간다 — 그때는 부르는 쪽의 시간제한이 받아 준다.
+ */
+export function closeConnections() {
+  try {
+    const d = globalThis[Symbol.for('undici.globalDispatcher.1')];
+    if (d && typeof d.close === 'function') return d.close().catch(() => {});
+  } catch { /* 없으면 그만 */ }
+  return Promise.resolve();
+}
+
 export function headersFor(authStyle, key, extra = {}) {
   const h = { 'Content-Type': 'application/json', Accept: 'application/json', ...extra };
   const style = AUTH_STYLES.find((s) => s.id === authStyle) ?? AUTH_STYLES[0];

package/src/backend/probe.js

@@ -5,6 +5,7 @@
 //   warn 되긴 하는데 조건이 붙음
 //   skip 앞 검사가 실패해 확인 불가
 import { req, headersFor, serverMessage } from './http.js';
+import { probeCtx } from './ctxsize.js';
 
 const READ_TOOL = {
   type: 'function',
@@ -146,7 +147,7 @@ export async function probe(conn, onStep = () => {}) {
     label: '시스템 메시지',
     status: sys.ok ? (sysHit ? 'ok' : 'warn') : 'no',
     detail: sys.ok
-      ? sysHit ? '지시를 따름' : '전달은 되나 모델이 잘 안 따름 — 규칙·스킬이 약하게 먹습니다'
+      ? sysHit ? '지시를 따름' : '전달은 되나 모델이 잘 안 따름 — 규칙·스킬이 약하게 적용됩니다'
       : serverMessage(sys),
     ms: sys.ms,
   });
@@ -330,26 +331,26 @@ export async function probe(conn, onStep = () => {}) {
   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 = '모델 정보에서 읽음';
-  }
+  //
+  // 한 자리만 보지 않는다. 서버마다 이름도 자리도 다르다 (ctxsize.js 참고).
+  // 여기서 작게 잡으면 프로그램 전체가 작아진다 — 답 길이 상한까지 이 값에서 나온다.
+  const 길이 = await probeCtx({ kind: shape, base, auth, key, model });
+  const ctx = 길이.value;
   add({
     id: 'ctx',
     label: '컨텍스트 길이',
     status: ctx ? 'ok' : 'warn',
-    detail: ctx ? `${ctx.toLocaleString()} 토큰 (${ctxNote})` : '서버가 알려주지 않음 — 설정에서 직접 지정합니다',
+    detail: ctx
+      ? `${ctx.toLocaleString()} 토큰 (${길이.source ?? '모델 정보'}에서 읽음)`
+        + (길이.max && 길이.loaded && 길이.max > 길이.loaded
+          ? ` · 이 모델은 ${길이.max.toLocaleString()} 까지 되는데 지금 ${길이.loaded.toLocaleString()} 로 올려 두셨습니다`
+          : '')
+      : '서버가 알려주지 않음 — /ctx 로 직접 지정하세요',
     ms: 0,
   });
   facts.ctx = ctx;
+  facts.ctxMax = 길이.max ?? null;
+  facts.ctxLoaded = 길이.loaded ?? null;
 
   return { facts, results };
 }