deel-local-cli 0.9.0 → 1.0.0

package/src/agent/salvage.js

@@ -0,0 +1,182 @@
+// 잘려 온 도구 호출에서 **건질 수 있는 만큼 건진다.**
+//
+// 무슨 일이 있었나:
+//   대시보드 HTML 한 장을 만들라고 시켰다. 모델이 Write 를 부르는데 인자 JSON 이
+//   출력 상한에서 잘렸다. 잘린 JSON 은 읽을 수 없으니 통째로 버렸다. 모델은
+//   똑같이 다시 시도했고, 또 같은 자리에서 잘렸다. 13번 만에 컨텍스트가 다 찼다.
+//   71초를 쓰고 **파일은 한 글자도 안 생겼다.**
+//
+//   그런데 잘린 그 JSON 안에는 이미 받아 놓은 250줄이 들어 있었다. 경로도 온전했다.
+//   버릴 이유가 없다. 250줄을 쓰고 "여기까지 썼으니 이어 붙여라" 라고 하면
+//   그 다음 호출은 나머지만 보내면 된다 — 잘릴 일이 없다.
+//
+// 왜 JSON.parse 로는 안 되나:
+//   JSON.parse 는 전부 맞거나 전부 틀리거나 둘 중 하나다. 마지막 따옴표가 없다는
+//   이유로 앞의 250줄까지 같이 버린다. 그래서 앞에서부터 읽어 나가다가 더 못
+//   읽는 자리에서 멈추는 방식으로 따로 만든다.
+//
+// 조심할 것:
+//   여기서 건진 값은 **완전하지 않다.** 마지막 값은 잘려 있다. 그래서 이 결과를
+//   쓰는 쪽은 어느 값이 잘렸는지(truncatedKey) 반드시 보고 판단해야 한다.
+//   Edit 의 old_string 을 반쪽만 건져 쓰면 엉뚱한 자리를 고친다. loop.js 가
+//   Write·Append 만 살리는 이유다.
+
+/**
+ * 잘린 JSON 에서 읽히는 데까지 읽는다.
+ *
+ * @returns {{args: object, keys: string[], truncatedKey: string|null, complete: boolean}}
+ *   args         온전히 읽은 값들 (+ 잘린 값 하나는 받은 데까지)
+ *   truncatedKey 잘린 값의 이름. null 이면 잘린 값 없이 그냥 끝난 것
+ *   complete     닫는 괄호까지 제대로 나왔나
+ */
+export function partialParse(raw) {
+  const s = String(raw ?? '');
+  const 빈것 = { args: {}, keys: [], truncatedKey: null, complete: false };
+  let i = 0;
+
+  const 공백건너뛰기 = () => { while (i < s.length && /\s/.test(s[i])) i++; };
+
+  공백건너뛰기();
+  if (s[i] !== '{') return 빈것;
+  i++;
+
+  const args = {};
+  const keys = [];
+
+  for (;;) {
+    공백건너뛰기();
+    if (i >= s.length) return { args, keys, truncatedKey: null, complete: false };
+    if (s[i] === '}') return { args, keys, truncatedKey: null, complete: true };
+    if (s[i] === ',') { i++; continue; }
+    if (s[i] !== '"') return { args, keys, truncatedKey: null, complete: false };
+
+    const k = 글읽기(s, i);
+    if (!k.complete) return { args, keys, truncatedKey: null, complete: false };  // 이름이 잘렸으면 값도 없다
+    i = k.end;
+    공백건너뛰기();
+    if (s[i] !== ':') return { args, keys, truncatedKey: null, complete: false };
+    i++;
+    공백건너뛰기();
+    if (i >= s.length) return { args, keys, truncatedKey: null, complete: false };
+
+    if (s[i] === '"') {
+      const v = 글읽기(s, i);
+      args[k.text] = v.text;
+      keys.push(k.text);
+      if (!v.complete) return { args, keys, truncatedKey: k.text, complete: false };
+      i = v.end;
+    } else if (s[i] === '{' || s[i] === '[') {
+      const end = 짝찾기(s, i);
+      // 안 닫힌 덩어리는 통째로 버린다. 반쪽 객체는 건져도 쓸 데가 없고,
+      // 잘못 건지면 있지도 않은 값이 있는 것처럼 보인다.
+      if (end < 0) return { args, keys, truncatedKey: null, complete: false };
+      try { args[k.text] = JSON.parse(s.slice(i, end + 1)); keys.push(k.text); } catch { /* 못 읽으면 버린다 */ }
+      i = end + 1;
+    } else {
+      // 숫자·true·false·null
+      let j = i;
+      while (j < s.length && !',}'.includes(s[j])) j++;
+      const 조각 = s.slice(i, j).trim();
+      if (j >= s.length) return { args, keys, truncatedKey: null, complete: false };   // 값이 잘렸다
+      try { args[k.text] = JSON.parse(조각); keys.push(k.text); } catch { /* 버린다 */ }
+      i = j;
+    }
+  }
+}
+
+/**
+ * JSON 문자열 하나를 읽는다. 끝까지 못 읽어도 읽은 데까지 돌려준다.
+ *
+ * 이 함수가 이 파일의 핵심이다. \n · \" · \\ 는 물론 \uXXXX 도 풀어야 한다 —
+ * 한글이 그 모양으로 오는 게이트웨이가 있다. 실제로 사용자 게이트웨이가 그랬다.
+ * 마지막에 escape 가 반토막 나 있으면(\ 하나만, 또는 \u12) 그건 버린다.
+ */
+function 글읽기(s, start) {
+  let i = start + 1;      // 여는 따옴표 다음
+  let out = '';
+  while (i < s.length) {
+    const ch = s[i];
+    if (ch === '"') return { text: out, end: i + 1, complete: true };
+    if (ch !== '\\') { out += ch; i++; continue; }
+
+    const n = s[i + 1];
+    if (n === undefined) break;                    // \ 하나만 남고 끝났다 — 버린다
+    if (n === 'u') {
+      const hex = s.slice(i + 2, i + 6);
+      if (hex.length < 4 || !/^[0-9a-fA-F]{4}$/.test(hex)) break;   // \u12 에서 끊겼다
+      out += String.fromCharCode(parseInt(hex, 16));
+      i += 6;
+      continue;
+    }
+    const 표 = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', '"': '"', '\\': '\\', '/': '/' };
+    if (n in 표) { out += 표[n]; i += 2; continue; }
+    out += n; i += 2;                              // 모르는 escape 는 글자 그대로
+  }
+  return { text: out, end: s.length, complete: false };
+}
+
+/** 여는 괄호에 맞는 닫는 괄호 자리. 없으면 -1. 따옴표 안은 안 센다. */
+function 짝찾기(s, start) {
+  const 열림 = s[start];
+  const 닫힘 = 열림 === '{' ? '}' : ']';
+  let depth = 0;
+  let 글속 = false;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (글속) {
+      if (ch === '\\') { i++; continue; }
+      if (ch === '"') 글속 = false;
+      continue;
+    }
+    if (ch === '"') { 글속 = true; continue; }
+    if (ch === 열림) depth++;
+    else if (ch === 닫힘) { depth--; if (depth === 0) return i; }
+  }
+  return -1;
+}
+
+/**
+ * 잘린 Write 호출을 '지금 바로 쓸 수 있는 것' 으로 바꾼다.
+ *
+ * 마지막 줄은 버린다. 반쪽 줄(`<div class="ca`)로 끝나 있으면 이어 붙이는 쪽이
+ * 그 반쪽에 정확히 맞춰 이어야 하는데, 약한 모델은 그걸 못 한다. 온전한 줄까지만
+ * 남기고 "그 다음 줄부터 쓰라" 고 하면 훨씬 쉬운 문제가 된다.
+ *
+ * @returns {{path: string, content: string, lines: number, lastLine: string}|null}
+ */
+export function 살린쓰기(raw) {
+  const r = partialParse(raw);
+  const path = r.args.file_path ?? r.args.path ?? r.args.filePath;
+  const body = r.args.content;
+  if (typeof path !== 'string' || !path.trim()) return null;
+  if (typeof body !== 'string' || !body) return null;
+  // 경로 자체가 잘렸으면 엉뚱한 자리에 쓴다. 그건 안 건진다.
+  if (r.truncatedKey === 'file_path' || r.truncatedKey === 'path') return null;
+
+  // 내용이 온전히 다 왔는데도 JSON 이 깨진 것이라면(뒤쪽 다른 인자에서 잘림)
+  // 마지막 줄을 버릴 이유가 없다.
+  const 내용잘림 = r.truncatedKey === 'content';
+  let content = body;
+  if (내용잘림) {
+    const 끝 = body.lastIndexOf('\n');
+    // 줄바꿈이 한 번도 없으면 **아무것도 안 건진다.**
+    //
+    // 이어 붙이라고 하려면 '어디까지 썼는지' 를 줄 단위로 말해 줄 수 있어야 한다.
+    // 온전한 줄이 하나도 없으면 반쪽 줄에 정확히 이어 붙이라고 부탁하는 셈인데,
+    // 약한 모델은 그걸 못 한다 — 앞을 다시 쓰거나 이음매가 어긋난다.
+    // 그럴 바에는 안 쓰고 '나눠 보내라' 고 하는 편이 낫다.
+    if (끝 < 0) return null;
+    content = body.slice(0, 끝 + 1);
+  }
+  if (!content) return null;
+
+  const lines = content.split('\n');
+  const 마지막 = [...lines].reverse().find((l) => l.trim()) ?? '';
+  return {
+    path: path.trim(),
+    content,
+    lines: content.endsWith('\n') ? lines.length - 1 : lines.length,
+    lastLine: 마지막.trim().slice(0, 60),
+    cut: 내용잘림,
+  };
+}

package/src/agent/session.js

@@ -2,6 +2,7 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { get as workMode, DEFAULT as WORK_DEFAULT } from './modes.js';
+import { toolSchemas } from '../tools/index.js';
 import { normalize as normLevel, DEFAULT as LEVEL_DEFAULT } from '../ui/level.js';
 
 // 토큰 추정 — 정확한 토크나이저 없이 대략만 센다.
@@ -23,8 +24,21 @@ const BASE_RULES = `너는 deel 다. 사용자의 작업 폴더 안에서 코드
 - 추측하지 말고 도구로 확인한다. 파일을 고치기 전에는 반드시 Read 로 읽는다.
 - Edit 의 old_string 은 공백과 들여쓰기까지 파일과 정확히 같아야 한다. 짧게 자르지 말고 앞뒤로 넉넉히 포함한다.
 - 한 번에 하나씩 고치고, 고친 뒤에는 무엇을 왜 고쳤는지 한 줄로 말한다.
+- 큰 파일은 한 번에 다 담지 않는다. 앞부분 300줄쯤을 Write 로 만들고, 나머지는 Append 를
+  여러 번 불러 끝까지 이어 붙인다. Append 는 Read 없이 바로 쓸 수 있다.
+  이어 붙일 때 앞부분을 다시 보내지 않는다 — 그러면 또 같은 자리에서 잘린다.
+- 같은 도구를 같은 인자로 다시 부르지 않는다. 결과는 같다. 본 것은 기억하고 다음으로 넘어간다.
+- 사용자가 볼 범위를 좁혀 말하면 그대로 따른다. 시키지 않은 폴더를 뒤지지 않는다.
 - 명령 실행이 필요하면 Bash 를 쓴다. 되돌릴 수 없는 명령은 막히니 다른 방법을 찾는다.
-- 사용자에게 답할 때는 한국어로, 짧게. 코드를 통째로 붙여넣지 말고 무엇이 달라졌는지 말한다.`;
+- 사용자에게 답할 때는 한국어로, 짧게. 코드를 통째로 붙여넣지 말고 무엇이 달라졌는지 말한다.
+
+다음에도 쓸 것은 남긴다:
+- 사용자가 규칙을 정하거나 하지 말라고 하면 Remember 로 한 줄 남긴다. 그 글은 앞으로
+  모든 요청에 실리니 한 문장으로. 이번 일에서만 쓰는 것은 안 남긴다.
+- "저번에"·"전에 정한 대로" 처럼 앞선 대화를 가리키면 되묻기 전에 Recall 로 찾는다.
+- 또 하게 될 절차를 끝냈으면 .deel/skills/<이름>/SKILL.md 로 적어 둔다.
+  앞머리에 name 과 description 을 넣고(--- 로 감싼다) 아래에 순서를 적는다.
+  쓰던 스킬에서 틀린 데를 찾으면 그 파일을 고친다.`;
 
 export class Session {
   constructor(conn, { root, mode = 'auto', work = null, level = null, think = 'medium', effort = 'save', web = true, maxSteps = 24 } = {}) {
@@ -43,6 +57,7 @@ export class Session {
     this.maxSteps = maxSteps;
     this.messages = [];
     this.filesRead = new Map();   // 경로 → 추정 토큰
+    this.changes = new Map();     // 경로 → {added, removed, times}. /diff 가 본다
     this.skills = [];             // 켜질 때 이 PC 에서 찾은 것들
     this.commands = [];
     this.plugins = [];
@@ -82,12 +97,28 @@ export class Session {
     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}`);
+
+    /*
+     * 지난 대화에서 정한 것.
+     *
+     * 이건 '찾으면 나오는' 것이 아니라 **처음부터 들어가 있어야** 하는 것이다.
+     * "우리 문서는 CP949 다" 를 매번 다시 설명하게 하면 두 번째부터 짜증이 나고
+     * 세 번째부터는 그냥 안 쓴다.
+     *
+     * 켤 때 한 번 읽어 들고 있는다. 매 턴 파일을 읽으면 긴 대화에서 그 횟수가
+     * 수십 번이 되고, 그 사이 사람이 파일을 고쳐 놓으면 대화 도중에 규칙이
+     * 바뀌는 셈이 된다 — 무엇 때문에 답이 달라졌는지 알 길이 없어진다.
+     */
+    if (this.memory) parts.push(this.memory);
     const listed = this.listedSkills();
     if (listed.length) {
       parts.push(
         '\n--- 쓸 수 있는 스킬 ---\n' +
         '필요한 것이 있으면 Skill 도구로 이름을 불러 본문을 받아라. 없으면 그냥 진행해라.\n' +
-        listed.map((s) => `- ${s.name}: ${s.description.slice(0, this.maxSkillDesc)}`).join('\n')
+        // 설명이 없는 스킬이 섞일 수 있다 — 남의 폴더에서 오는 파일이라
+        // 앞머리(frontmatter)가 빠지곤 한다. 여기서 터지면 시스템 프롬프트를
+        // 못 만들어 **매 턴** 죽는다. 목록 명령 하나가 아니라 대화 전체가 막힌다.
+        listed.map((s) => `- ${s.name}: ${String(s.description ?? '').slice(0, this.maxSkillDesc)}`).join('\n')
       );
       const rest = this.skills.filter((s) => s.enabled).length - listed.length;
       if (rest > 0) parts.push(`(그 밖에 ${rest}개가 더 있으나 자리가 모자라 안 실었다.)`);
@@ -110,18 +141,45 @@ export class Session {
 
   noteRead(path, text) { this.filesRead.set(path, estimateTokens(text)); }
 
+  /**
+   * 이번 대화에서 어느 파일이 얼마나 바뀌었는지 적어 둔다. /diff 가 이걸 본다.
+   *
+   * 견준 결과를 통째로 들고 있지는 않는다 — 파일 내용 두 벌이 딸려 온다.
+   * 스무 번 고치면 그것만으로 수십 MB 다. 여기서는 숫자만 센다.
+   */
+  noteChange(path, d) {
+    if (!path || !d) return;
+    const 앞 = this.changes.get(path) ?? { added: 0, removed: 0, times: 0 };
+    앞.added += d.added ?? 0;
+    앞.removed += d.removed ?? 0;
+    앞.times += 1;
+    this.changes.set(path, 앞);
+  }
+
   // 모델에 실제로 보낼 배열.
   wire() {
     return [{ role: 'system', content: this.systemPrompt() }, ...this.messages];
   }
 
-  // /context 가 그릴 내역.
+  /**
+   * /context 가 그릴 내역.
+   *
+   * 여기서 나온 used 는 화면 숫자로만 쓰이는 게 아니다. effort.js 가 이 값으로
+   * '남은 자리' 를 셈해 출력 상한을 정한다. 그래서 여기서 덜 세면 **매 요청마다
+   * 그만큼 몰래 나간다** — 다 찼는데 안 찼다고 알고 있는 상태가 된다.
+   *
+   * 전에는 두 가지를 안 셌다.
+   *   · 도구 스키마 JSON — 도구 11종의 설명과 인자 정의. 약 1,800토큰이다.
+   *     매 요청에 통째로 들어가는데 어느 칸에도 안 잡혔다.
+   *   · 지금 모드 문구 — modes.js 의 say. 모드마다 수백 토큰이다.
+   */
   breakdown() {
-    const sys = estimateTokens(BASE_RULES) + estimateTokens(`작업 폴더: ${this.root}`);
+    const sys = estimateTokens(BASE_RULES) + estimateTokens(`작업 폴더: ${this.root}`)
+      + estimateTokens(workMode(this.effectiveWork()).say ?? '');
     const rules = this.rules ? estimateTokens(this.rules.text) : 0;
     const listed = this.listedSkills();
     const skills = listed.length
-      ? estimateTokens(listed.map((s) => `${s.name}: ${s.description.slice(0, this.maxSkillDesc)}`).join('\n'))
+      ? estimateTokens(listed.map((s) => `${s.name}: ${String(s.description ?? '').slice(0, this.maxSkillDesc)}`).join('\n'))
       : 0;
 
     let history = 0;
@@ -132,10 +190,20 @@ export class Session {
       if (m.role === 'tool') files += t; else history += t;
     }
 
+    // 도구 정의도 매 요청에 실려 나간다. 세는 값이라기보다 '이미 나간 값' 이다.
+    const 도구 = this.#도구토큰();
+
+    // 기억도 매 요청에 통째로 나간다. 안 세면 '남은 자리' 가 그만큼 뻥튀기되고,
+    // effort.js 가 그 값으로 출력 상한을 잡으므로 답이 조용히 잘리기 시작한다.
+    const 기억 = this.memory ? estimateTokens(this.memory) : 0;
+    const 기억줄 = this.memory ? this.memory.split('\n').filter((l) => l.startsWith('- ')).length : 0;
+
     const rows = [
       { label: '시스템 프롬프트', n: sys },
       { label: this.rules ? `규칙 (${this.rules.name})` : '규칙 (없음)', n: rules },
+      { label: `기억 (${기억줄}줄)`, n: 기억 },
       { label: `스킬 목록 (${listed.length}/${this.skills.length}개)`, n: skills },
+      { label: '도구 정의', n: 도구 },
       { label: '대화 이력', n: history },
       { label: `도구 결과 (파일 ${this.filesRead.size}개)`, n: files },
     ];
@@ -144,18 +212,80 @@ export class Session {
     return { rows, used, total, left: Math.max(0, total - used) };
   }
 
-  // 오래된 대화를 잘라낸다. 앞의 2턴과 최근 절반만 남긴다.
+  /**
+   * 도구 정의가 몇 토큰인가.
+   *
+   * 모드가 바뀌면 도구 목록도 바뀌므로 모드별로 한 번씩만 재고 넣어 둔다.
+   * 매 턴 JSON.stringify 를 하면 그 자체가 아깝다 — 값은 안 바뀌는데.
+   */
+  #도구잰것 = new Map();
+  #도구토큰() {
+    // 밖에서 붙인 도구 수까지 열쇠에 넣는다. 서버가 붙고 떨어지면 값이 달라진다.
+    const mcp수 = (this.mcp ?? []).reduce((n, s) => n + (s.도구?.length ?? 0), 0);
+    const 열쇠 = `${this.effectiveWork()}|${this.skills?.length ? 'skill' : ''}|${this.web !== false ? 'web' : ''}|mcp${mcp수}`;
+    if (this.#도구잰것.has(열쇠)) return this.#도구잰것.get(열쇠);
+    let n = 0;
+    try {
+      const list = toolSchemas(null, {
+        hasSkills: (this.skills?.length ?? 0) > 0,
+        web: this.web !== false,
+        work: this.effectiveWork(),
+        mcp: this.mcp ?? null,
+      });
+      n = estimateTokens(JSON.stringify(list));
+    } catch { n = 0; }
+    this.#도구잰것.set(열쇠, n);
+    return n;
+  }
+
+  /**
+   * 오래된 대화를 잘라낸다. 앞의 2턴과 최근 절반만 남긴다.
+   *
+   * 자르는 자리를 **아무 데나 잡으면 안 된다.** 도구 호출과 그 결과는 한 몸이라,
+   * 사이를 끊으면 규격 위반이 되어 그 뒤 모든 요청이 400 으로 거절당한다.
+   *
+   * 이게 실제로 있었던 길이다 — 접기(compact)가 요약을 못 받으면 여기로
+   * 물러섰는데, 여기가 짝을 안 맞췄다. 화면에는 노란 안내 한 줄이 뜨고,
+   * 그 뒤로 무엇을 해도 400 이 났다. 원인은 두 화면 전이라 이어 붙일 수 없고,
+   * /clear 말고는 길이 없었다. 물러설 자리가 더 큰 사고를 만든 셈이다.
+   */
   trim() {
     if (this.messages.length < 12) return 0;
-    const keepHead = 2;
-    const keepTail = Math.floor(this.messages.length / 2);
-    const dropped = this.messages.length - keepHead - keepTail;
+    const keepHead = safeHead(this.messages, 2);
+    const keepTail = safeCut(this.messages, this.messages.length - Math.floor(this.messages.length / 2));
+    const dropped = keepTail - keepHead;
     if (dropped <= 0) return 0;
     this.messages = [
       ...this.messages.slice(0, keepHead),
       { role: 'user', content: `(앞선 대화 ${dropped}개를 줄였습니다. 필요하면 파일을 다시 읽으세요.)` },
-      ...this.messages.slice(-keepTail),
+      ...this.messages.slice(keepTail),
     ];
     return dropped;
   }
 }
+
+/**
+ * 도구 호출과 결과가 갈라지지 않는 자리를 찾는다.
+ * i 번째부터 남긴다고 할 때, 안전한 i 로 옮겨 준다.
+ *
+ * 접기(compact.js)와 그냥 줄이기(trim)가 **같은 함수**를 쓴다. 전에는 접기에만
+ * 있었고 줄이기는 제멋대로 잘랐다. 그래서 접기가 실패해 줄이기로 물러선 순간
+ * 대화가 망가졌다 — 안전망이 사고를 만드는 자리는 늘 이런 모양이다.
+ */
+export function safeCut(messages, i) {
+  let k = Math.max(0, Math.min(i, messages.length));
+  // tool 결과로 시작하면 그 앞의 assistant(tool_calls) 가 없어 규격이 깨진다. 앞으로 당긴다.
+  while (k > 0 && messages[k]?.role === 'tool') k--;
+  return k;
+}
+
+/**
+ * 머리 쪽 자르는 자리.
+ * 머리가 '결과를 기다리는 도구 호출' 로 끝나면 그 결과가 접혀 없어져 짝이 깨진다.
+ * 그런 assistant 는 머리에서 뺀다 — 접히는 쪽에 같이 넘긴다.
+ */
+export function safeHead(messages, k) {
+  let h = Math.max(0, Math.min(k, messages.length));
+  while (h > 0 && messages[h - 1]?.tool_calls?.length) h--;
+  return h;
+}

package/src/agent/store.js

@@ -143,30 +143,53 @@ function firstAsk(messages) {
 /**
  * 이 폴더에 남아 있는 대화 목록. 최근 것이 위로.
  */
-export function list(root, { limit = 20 } = {}) {
+/**
+ * 지난 대화 목록.
+ *
+ * **먼저 정렬하고 나서 필요한 것만 읽는다.** 순서가 중요하다.
+ *
+ * 전에는 폴더에 있는 파일을 **전부 열어서** 한 줄씩 JSON 으로 풀고, 그 다음에
+ * 정렬해서 20개만 남겼다. 몇 주 쓰면 수십 MB 를 매번 읽는 셈이다. 그리고 이건
+ * 켤 때마다 돈다(repl 이 prune 을 부른다) — 머리글도 안 뜬 채로 몇 초씩 멈춰
+ * 있어서, 사용자 눈에는 프로그램이 죽은 것처럼 보인다.
+ *
+ * 정렬에 필요한 것은 파일 시각뿐이고, 그건 안 열어도 안다.
+ *
+ * @param {object} o
+ * @param {boolean} o.속까지  false 면 파일을 안 열고 시각·크기만 본다 (prune 용)
+ */
+export function list(root, { limit = 20, 속까지 = true } = {}) {
   const dir = sessionsDir(root);
   if (!existsSync(dir)) return [];
-  const out = [];
+
+  // 1) 시각만 모은다. 파일을 열지 않는다.
+  const 후보 = [];
   for (const name of readdirSync(dir)) {
     if (!name.endsWith('.jsonl')) continue;
-    const id = name.slice(0, -6);
     const file = join(dir, name);
     let st;
     try { st = statSync(file); } catch { continue; }
-    const { meta, messages } = new Store(root, id).load();
-    if (!messages.length) continue;
+    후보.push({ id: name.slice(0, -6), file, at: st.mtime, bytes: st.size });
+  }
+  후보.sort((a, b) => b.at - a.at);
+
+  if (!속까지) return 후보.slice(0, limit);
+
+  // 2) 앞에서부터 필요한 개수만 실제로 읽는다.
+  const out = [];
+  for (const c of 후보) {
+    if (out.length >= limit) break;
+    const { meta, messages } = new Store(root, c.id).load();
+    if (!messages.length) continue;      // 빈 파일은 목록에 안 올린다
     out.push({
-      id,
-      file,
-      at: st.mtime,
-      bytes: st.size,
+      ...c,
       model: meta?.model ?? '?',
       turns: messages.filter((m) => m.role === 'user').length,
       messages: messages.length,
       first: firstAsk(messages),
     });
   }
-  return out.sort((a, b) => b.at - a.at).slice(0, limit);
+  return out;
 }
 
 export function remove(root, id) {
@@ -186,7 +209,9 @@ export function latest(root) {
  * 최근 keep 개는 무조건 남기고, 그보다 오래되고 days 를 넘긴 것만 지운다.
  */
 export function prune(root, { keep = 30, days = 30 } = {}) {
-  const all = list(root, { limit: 1000 });
+  // 지울지 말지는 파일 시각만 보면 안다. 내용은 필요 없다 —
+  // 여기서 전부 읽던 것이 켤 때 몇 초씩 멈추던 원인이었다.
+  const all = list(root, { limit: 1000, 속까지: false });
   const 자를것 = all.slice(keep).filter((s) => (Date.now() - s.at.getTime()) > days * 86400000);
   for (const s of 자를것) { try { rmSync(s.file, { force: true }); } catch {} }
   return 자를것.length;