deel-local-cli 0.5.0 → 0.8.0

package/src/agent/loop.js

@@ -3,6 +3,10 @@
 import { chat, chatStream, assistantMessage, toolMessage } from '../backend/adapter.js';
 import { toolSchemas, runTool, TOOLS } from '../tools/index.js';
 import { isMutating } from '../safety/guard.js';
+import { effortFor, tokensFor, fullCap, wasCut } from './effort.js';
+import { compact, shouldCompact } from './compact.js';
+import { isOffline } from '../safety/network.js';
+import { get as workMode } from './modes.js';
 
 // think 값을 규격에 맞게. 'off' 는 사고를 끈다.
 function thinkFor(conn, level) {
@@ -10,39 +14,121 @@ function thinkFor(conn, level) {
   return level;
 }
 
-export async function* run(session, ctx, userText) {
+// 아무것도 안 바꾸는 도구들. 이것들만 동시에 돌린다.
+//
+// 왜 이것만인가:
+//   Read 세 개를 동시에 하는 것은 안전하다 — 서로 안 건드린다.
+//   Write·Edit 을 동시에 돌리면 같은 파일을 두 갈래로 고칠 수 있고,
+//   되돌리기 스냅샷 순서도 뒤엉킨다. Bash 는 무슨 짓을 할지 알 수 없다.
+//   그래서 '읽기만 하는 것' 이라고 확실한 도구만 묶는다.
+const 읽기전용 = new Set(['Read', 'Glob', 'Grep', 'Skill', 'WebFetch']);
+
+/**
+ * 호출 목록을 '같이 돌려도 되는 덩어리' 로 자른다.
+ * 읽기 전용이 이어지면 한 덩어리, 그 밖의 것은 하나씩 따로.
+ */
+export function 묶기(calls) {
+  const out = [];
+  for (const call of calls) {
+    const 안전 = 읽기전용.has(call.name);
+    const 끝 = out.at(-1);
+    if (안전 && 끝?.parallel) 끝.calls.push(call);
+    else out.push({ parallel: 안전, calls: [call] });
+  }
+  return out;
+}
+
+export async function* run(session, ctx, userText, { signal = null } = {}) {
   session.push({ role: 'user', content: userText });
   ctx.audit.turn(userText);
   ctx.history.nextTurn();
 
   const conn = session.conn;
-  const tools = toolSchemas(null, { hasSkills: (session.skills?.length ?? 0) > 0 });
+
+  /**
+   * 중단하고 나갈 때 대화를 성한 상태로 남긴다.
+   *
+   * 모델이 도구를 부르겠다고 해 놓고 결과가 안 들어간 채로 끝나면, 다음에 이어할 때
+   * 그 배열을 그대로 보낼 수 없다 — 서버가 400 을 낸다. 그래서 부른 만큼
+   * '중단됨' 결과를 채워 짝을 맞춘다.
+   */
+  const 짝맞추기 = () => {
+    const last = session.messages.at(-1);
+    const calls = last?.tool_calls ?? [];
+    if (!calls.length) return;
+    const 이미 = session.messages.filter((m) => m.role === 'tool').length;
+    for (const t of calls) {
+      session.push(toolMessage(conn.kind, {
+        callId: t.id ?? `call_${이미 + 1}`,
+        name: t.function?.name ?? t.name ?? '?',
+        content: '사용자가 중단했습니다. 실행하지 않았습니다.',
+      }));
+    }
+  };
+  const tools = toolSchemas(null, {
+    hasSkills: (session.skills?.length ?? 0) > 0,
+    web: session.web !== false && !isOffline(),   // 오프라인이면 웹 도구는 아예 안 보여 준다
+    work: session.work,                           // 작업 모드가 쓰는 것만 (modes.js)
+  });
+  // 모드마다 생각의 배분과 걸음 수가 다르다. 사용자가 따로 정했으면 그걸 존중한다.
+  const 모드 = workMode(session.work);
+  const effort = session.effortSet ? session.effort : (모드.effort ?? session.effort);
+  const think = session.thinkSet ? session.think : (모드.think ?? session.think);
+  const maxSteps = session.stepsSet ? session.maxSteps : (모드.steps ?? session.maxSteps);
   const attempted = new Set();   // 같은 변경성 명령을 두 번 실행하지 않기 위한 기록
   let steps = 0;
+  let lastToolFailed = false;    // 직전 단계에서 도구가 오류를 냈나 → 다음 판단은 세게
 
-  while (steps < session.maxSteps) {
+  while (steps < maxSteps) {
     steps++;
-    const opts = {
+    // 단계마다 필요한 생각의 양이 다르다. effort.js 가 그 배분을 갖고 있다.
+    const stage = steps === 1 ? 'plan' : lastToolFailed ? 'fix' : 'work';
+    const level = effortFor(think, effort, stage);
+    // 상한은 모델 컨텍스트와 지금 찬 양에서 계산한다. 고정 숫자가 아니다.
+    const room = { ctx: conn.ctx ?? 0, used: session.breakdown().used, max: conn.maxTokens ?? null };
+    const cap = tokensFor(effort, stage, room);
+    yield { type: 'stage', stage, level, cap, step: steps };
+
+    const ask = (maxTokens, think) => ({
       messages: session.wire(),
       tools,
-      think: thinkFor(conn, session.think),
-      maxTokens: 4096,
-    };
+      think: thinkFor(conn, think),
+      maxTokens,
+      signal,
+    });
 
     let msg;
-    try {
+    const askModel = async function* (maxTokens, think) {
       if (conn.streaming) {
-        for await (const ev of chatStream(conn, opts)) {
+        for await (const ev of chatStream(conn, ask(maxTokens, think))) {
           if (ev.type === 'done') msg = ev.message;
           else yield ev;
         }
       } else {
         yield { type: 'waiting' };
-        msg = await chat(conn, opts);
+        msg = await chat(conn, ask(maxTokens, think));
         if (msg.thinking) yield { type: 'thinking', text: msg.thinking };
         if (msg.content) yield { type: 'content', text: msg.content };
       }
+    };
+
+    try {
+      yield* askModel(cap, level);
+
+      // 아낀 상한 때문에 대답이 잘렸다면, 그 단계만 상한을 풀어 한 번 다시 부른다.
+      // 잘린 채로 넘어가면 도구 호출이 반토막 나서 조용히 실패한다 —
+      // 생각을 많이 하는 모델에서 특히 잘 생긴다.
+      const full = fullCap(room);
+      if (wasCut(msg) && cap < full) {
+        yield { type: 'retry', why: '대답이 상한에서 잘렸습니다', from: cap, to: full };
+        yield* askModel(full, level);
+      }
     } catch (err) {
+      if (err?.name === 'Aborted' || signal?.aborted) {
+        짝맞추기();
+        yield { type: 'aborted', steps };
+        return;
+      }
       yield { type: 'error', text: err.message };
       return;
     }
@@ -58,66 +144,106 @@ export async function* run(session, ctx, userText) {
       return;
     }
 
-    // 도구를 순서대로 실행한다.
-    for (const call of msg.toolCalls) {
-      if (!TOOLS[call.name]) {
-        session.push(toolMessage(conn.kind, {
-          callId: call.id, name: call.name,
-          content: `모르는 도구입니다. 쓸 수 있는 것: ${Object.keys(TOOLS).join(', ')}`,
-        }));
-        yield { type: 'tool', name: call.name, args: call.args, result: { error: '모르는 도구' } };
-        continue;
-      }
+    // 도구를 돌린다. 읽기만 하는 것들이 이어지면 한꺼번에, 나머지는 하나씩.
+    lastToolFailed = false;
+    const 거절 = (call, note) => {
+      lastToolFailed = true;
+      session.push(toolMessage(conn.kind, { callId: call.id, name: call.name, content: note }));
+    };
 
-      // 변경성 명령은 실패해도 다시 실행하지 않는다 — 두 번 돌면 사고다.
-      if (call.name === 'Bash' && isMutating(call.args?.command)) {
-        const key = String(call.args.command).trim();
-        if (attempted.has(key)) {
-          const note = '같은 변경성 명령을 다시 실행하지 않습니다. 두 번 실행되면 사고가 납니다.';
-          session.push(toolMessage(conn.kind, { callId: call.id, name: call.name, content: note }));
-          yield { type: 'tool', name: call.name, args: call.args, result: { error: note } };
-          continue;
+    for (const 덩어리 of 묶기(msg.toolCalls)) {
+      // 돌리는 중에 끊었다면, 남은 것은 실행하지 않고 결과 자리만 채운다.
+      // 자리를 비우면 짝이 깨져 다음에 이어할 수 없다.
+      if (signal?.aborted) {
+        for (const call of 덩어리.calls) {
+          session.push(toolMessage(conn.kind, {
+            callId: call.id, name: call.name,
+            content: '사용자가 중단했습니다. 실행하지 않았습니다.',
+          }));
         }
-        attempted.add(key);
+        continue;
       }
 
-      // 모드에 따라 물어본다. 기본(auto)은 안 묻고 되돌리기로 대응한다.
-      const needsOk = session.mode === 'strict'
-        ? ['Write', 'Edit', 'Bash'].includes(call.name)
-        : session.mode === 'confirm'
-          ? (call.name === 'Bash' && isMutating(call.args?.command))
-          : false;
-      if (needsOk && ctx.confirm) {
-        const ok = await ctx.confirm(call.name, call.args);
-        if (!ok) {
-          const note = '사용자가 거부했습니다. 다른 방법을 찾거나 이유를 물어보세요.';
-          session.push(toolMessage(conn.kind, { callId: call.id, name: call.name, content: note }));
-          yield { type: 'tool', name: call.name, args: call.args, result: { error: '거부됨' } };
+      // 먼저 하나씩 걸러 낸다 — 물어보는 것도 여기서. 실제 실행은 통과한 것만.
+      const 실행할것 = [];
+      for (const call of 덩어리.calls) {
+        if (!TOOLS[call.name]) {
+          거절(call, `모르는 도구입니다. 쓸 수 있는 것: ${Object.keys(TOOLS).join(', ')}`);
+          yield { type: 'tool', name: call.name, args: call.args, result: { error: '모르는 도구' } };
           continue;
         }
-      }
 
-      yield { type: 'tool_start', name: call.name, args: call.args };
-      const t0 = Date.now();
-      const result = await runTool(call.name, call.args, ctx);
-      const ms = Date.now() - t0;
-      session.usage.ms += ms;
-
-      if (call.name === 'Read' && result.content) session.noteRead(call.args.file_path, result.content);
+        // 변경성 명령은 실패해도 다시 실행하지 않는다 — 두 번 돌면 사고다.
+        if (call.name === 'Bash' && isMutating(call.args?.command)) {
+          const key = String(call.args.command).trim();
+          if (attempted.has(key)) {
+            const note = '같은 변경성 명령을 다시 실행하지 않습니다. 두 번 실행되면 사고가 납니다.';
+            거절(call, note);
+            yield { type: 'tool', name: call.name, args: call.args, result: { error: note } };
+            continue;
+          }
+          attempted.add(key);
+        }
 
-      session.push(toolMessage(conn.kind, {
-        callId: call.id,
-        name: call.name,
-        content: result.error ? `오류: ${result.error}` : result.content ?? '',
-      }));
-      yield { type: 'tool', name: call.name, args: call.args, result, ms };
+        // 모드에 따라 물어본다. 기본(auto)은 안 묻고 되돌리기로 대응한다.
+        const needsOk = session.mode === 'strict'
+          ? ['Write', 'Edit', 'Bash'].includes(call.name)
+          : session.mode === 'confirm'
+            ? (call.name === 'Bash' && isMutating(call.args?.command))
+            : false;
+        if (needsOk && ctx.confirm) {
+          const ok = await ctx.confirm(call.name, call.args);
+          if (!ok) {
+            거절(call, '사용자가 거부했습니다. 다른 방법을 찾거나 이유를 물어보세요.');
+            yield { type: 'tool', name: call.name, args: call.args, result: { error: '거부됨' } };
+            continue;
+          }
+        }
+        실행할것.push(call);
+      }
+      if (!실행할것.length) continue;
+
+      // 여럿을 같이 돌릴 때는 '시작' 을 따로 알리지 않는다.
+      // 화면에서 이름 셋이 먼저 뜨고 결과 셋이 뒤에 몰려 붙으면, 어느 결과가
+      // 어느 파일 것인지 읽을 수 없다. 그럴 때는 끝난 것부터 이름과 결과를 함께 그린다.
+      const 함께 = 실행할것.length > 1;
+      if (!함께) yield { type: 'tool_start', name: 실행할것[0].name, args: 실행할것[0].args };
+      else yield { type: 'tools_start', names: 실행할것.map((x) => x.name), count: 실행할것.length };
+
+      const 한개 = async (call) => {
+        const t0 = Date.now();
+        let result;
+        try { result = await runTool(call.name, call.args, ctx); }
+        catch (err) { result = { error: String(err?.message ?? err) }; }
+        return { call, result, ms: Date.now() - t0 };
+      };
+
+      // 여럿이면 동시에. 읽기만 하는 것들이라 서로 방해하지 않는다.
+      const 결과들 = 함께
+        ? await Promise.all(실행할것.map(한개))
+        : [await 한개(실행할것[0])];
+
+      for (const { call, result, ms } of 결과들) {
+        session.usage.ms += ms;
+        if (result.error) lastToolFailed = true;
+        if (call.name === 'Read' && result.content) session.noteRead(call.args.file_path, result.content);
+        session.push(toolMessage(conn.kind, {
+          callId: call.id,
+          name: call.name,
+          content: result.error ? `오류: ${result.error}` : result.content ?? '',
+        }));
+        yield { type: 'tool', name: call.name, args: call.args, result, ms, parallel: 함께 };
+      }
     }
 
-    // 컨텍스트가 차오르면 오래된 대화를 줄인다.
-    const b = session.breakdown();
-    if (b.used > b.total * 0.8) {
-      const dropped = session.trim();
-      if (dropped) yield { type: 'trimmed', dropped };
+    if (signal?.aborted) { yield { type: 'aborted', steps }; return; }
+
+    // 컨텍스트가 차오르면 오래된 대화를 '요약해서' 접는다. 그냥 자르면 하던 일을 잊는다.
+    if (shouldCompact(session)) {
+      yield { type: 'compacting' };
+      const r = await compact(session, { auto: true });
+      if (r.ok) yield { type: 'compacted', ...r };
+      else yield { type: 'compact_failed', why: r.why };
     }
   }
 

package/src/agent/modes.js

@@ -0,0 +1,153 @@
+// 작업 모드. 지금 무슨 일을 하는 중인지에 따라 도구·추론·말투를 한꺼번에 바꾼다.
+//
+// 승인 정책(auto/confirm/strict)과는 다른 축이다. 헷갈리면 안 된다.
+//   승인 정책 = 얼마나 물어보나
+//   작업 모드 = 무슨 일을 하는 중인가
+// 둘은 곱해진다. '설계 모드 + strict' 도, '코드 모드 + auto' 도 말이 된다.
+//
+// 왜 도구를 아예 빼는가:
+//   설계 모드에서 파일을 고치면 안 된다고 프롬프트로 부탁할 수도 있다.
+//   그런데 모델은 부탁을 잊는다. 아예 목록에서 빼면 잊을 것이 없다.
+//   오프라인일 때 웹 도구를 숨기는 것과 같은 방식이다.
+
+// 읽기만 하는 도구. 무엇을 바꾸지 않는다.
+const 읽기 = ['Read', 'Glob', 'Grep', 'WebFetch', 'Skill'];
+// 계획을 적는 도구. 파일을 안 건드리므로 읽기 전용 모드에서도 준다.
+const 계획 = ['TodoWrite'];
+// 바꾸는 도구.
+const 쓰기 = ['Write', 'Edit', 'Bash'];
+
+export const MODES = {
+  code: {
+    id: 'code',
+    name: '코드',
+    en: 'Code',
+    glyph: '◆',
+    hint: '고치고 만든다',
+    tools: [...읽기, ...계획, ...쓰기],
+    effort: 'save',            // 첫 판단만 세게, 이어가기는 얕게
+    think: null,               // 사용자가 정한 값을 그대로 쓴다
+    steps: 24,
+    say: '코드를 읽고 고칩니다. 고치기 전에 반드시 먼저 읽으세요.',
+  },
+
+  architect: {
+    id: 'architect',
+    name: '설계',
+    en: 'Architect',
+    glyph: '◈',
+    hint: '구조를 짠다 · 파일은 안 건드림',
+    tools: [...읽기, ...계획],
+    effort: 'deep',
+    think: 'high',
+    steps: 20,
+    say: '구조와 설계를 다룹니다. 파일을 바꾸는 도구는 주어지지 않았습니다. '
+       + '지금 코드를 충분히 읽고, 어디를 어떻게 바꿀지 근거와 함께 제안하세요. '
+       + '고르는 이유와 버리는 이유를 같이 적으세요.',
+  },
+
+  ask: {
+    id: 'ask',
+    name: '묻기',
+    en: 'Ask',
+    glyph: '◇',
+    hint: '설명만 · 아무것도 안 바꿈',
+    tools: [...읽기],
+    effort: 'even',
+    think: 'low',
+    steps: 8,
+    say: '질문에 답하고 설명합니다. 시키지 않은 일을 벌이지 마세요. '
+       + '코드를 읽어 근거를 대되, 고치라는 말이 없으면 고칠 것을 제안하지 마세요.',
+  },
+
+  debug: {
+    id: 'debug',
+    name: '디버그',
+    en: 'Debug',
+    glyph: '◉',
+    hint: '원인을 찾는다',
+    tools: [...읽기, ...계획, ...쓰기],
+    effort: 'deep',
+    think: 'high',
+    steps: 32,               // 원인 찾기는 왔다 갔다 하므로 여유를 준다
+    say: '무엇이 잘못됐는지 찾습니다. 고치기 전에 원인을 먼저 밝히세요. '
+       + '짐작으로 고치지 말고, 확인할 수 있는 것을 확인하세요 — 로그를 보고, '
+       + '작은 것을 실제로 돌려 보고, 무엇이 사실인지 말한 다음 고치세요.',
+  },
+
+  plan: {
+    id: 'plan',
+    name: '계획',
+    en: 'Plan',
+    glyph: '☰',
+    hint: '먼저 계획 · 승인 뒤 실행',
+    tools: [...읽기, ...계획],
+    effort: 'deep',
+    think: 'high',
+    steps: 16,
+    say: '먼저 계획만 세웁니다. 파일을 바꾸는 도구는 주어지지 않았습니다. '
+       + '무엇을 어떤 순서로 할지, 위험이 무엇인지 적고 멈추세요. '
+       + '사용자가 승인하면 그때 코드 모드로 바뀝니다.',
+  },
+
+  orchestrator: {
+    id: 'orchestrator',
+    name: '총괄',
+    en: 'Orchestrator',
+    glyph: '❋',
+    hint: '큰 일을 쪼개서 끝까지',
+    tools: [...읽기, ...계획, ...쓰기],
+    effort: 'save',
+    think: null,
+    steps: 40,               // 여러 갈래를 끝까지 끌고 가야 한다
+    say: '여러 단계가 걸리는 일을 끝까지 끌고 갑니다. '
+       + '먼저 TodoWrite 로 할 일을 쪼개 적고, 하나씩 끝낼 때마다 갱신하세요. '
+       + '한 번에 하나만 진행 중으로 두세요. 다 끝나면 무엇을 했는지 요약하세요.',
+  },
+};
+
+export const ORDER = ['code', 'plan', 'architect', 'debug', 'ask', 'orchestrator'];
+export const DEFAULT = 'code';
+
+/** 이름을 관대하게 받는다. 한글·영문·줄임말 다 통한다. */
+export function normalize(v) {
+  const s = String(v ?? '').trim().toLowerCase();
+  if (!s) return null;
+  if (MODES[s]) return s;
+  const 별명 = {
+    '코드': 'code', 'c': 'code',
+    '계획': 'plan', '플랜': 'plan', 'p': 'plan',
+    '설계': 'architect', '아키': 'architect', 'arch': 'architect', 'a': 'architect',
+    '디버그': 'debug', '버그': 'debug', 'd': 'debug',
+    '묻기': 'ask', '질문': 'ask', '일상': 'ask', 'q': 'ask',
+    '총괄': 'orchestrator', '오케': 'orchestrator', 'orch': 'orchestrator', 'o': 'orchestrator',
+  };
+  return 별명[s] ?? null;
+}
+
+export function get(id) {
+  return MODES[normalize(id) ?? DEFAULT];
+}
+
+/** Shift+Tab 으로 돌릴 때 다음 모드. */
+export function next(id) {
+  const i = ORDER.indexOf(normalize(id) ?? DEFAULT);
+  return ORDER[(i + 1) % ORDER.length];
+}
+
+/** 이 모드가 파일을 바꿀 수 있나. 화면에 자물쇠를 그릴지 정하는 데 쓴다. */
+export function canWrite(id) {
+  return get(id).tools.some((t) => 쓰기.includes(t));
+}
+
+/**
+ * 이 모드에서 모델에게 보여 줄 도구 이름들.
+ *
+ * 있는 것 중에서 고르는 것이지, 없는 것을 만들어 주지 않는다.
+ * 스킬이 없으면 Skill 은 애초에 없고, 오프라인이면 WebFetch 가 없다.
+ * 그 판단은 부르는 쪽이 이미 했다.
+ */
+export function allow(id, 있는것) {
+  const 허용 = new Set(get(id).tools);
+  return 있는것.filter((name) => 허용.has(name));
+}

package/src/agent/session.js

@@ -1,6 +1,8 @@
 // 대화 상태와 컨텍스트 셈. /context 가 보여주는 숫자가 여기서 나온다.
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { get as workMode, DEFAULT as WORK_DEFAULT } from './modes.js';
+import { normalize as normLevel, DEFAULT as LEVEL_DEFAULT } from '../ui/level.js';
 
 // 토큰 추정 — 정확한 토크나이저 없이 대략만 센다.
 // 한글은 글자당 약 1토큰, 영문·코드는 약 4글자당 1토큰으로 본다.
@@ -25,11 +27,16 @@ const BASE_RULES = `너는 deel 다. 사용자의 작업 폴더 안에서 코드
 - 사용자에게 답할 때는 한국어로, 짧게. 코드를 통째로 붙여넣지 말고 무엇이 달라졌는지 말한다.`;
 
 export class Session {
-  constructor(conn, { root, mode = 'auto', think = 'medium', maxSteps = 24 } = {}) {
+  constructor(conn, { root, mode = 'auto', work = null, level = null, think = 'medium', effort = 'save', web = true, maxSteps = 24 } = {}) {
     this.conn = conn;
     this.root = root;
-    this.mode = mode;
-    this.think = think;
+    this.mode = mode;        // 승인 정책 — 얼마나 물어보나 (auto/confirm/strict)
+    this.work = work ?? WORK_DEFAULT;   // 작업 모드 — 무슨 일을 하는 중인가 (modes.js)
+    // 사용자 수준 — 화면에 무엇을 내놓을지만 정한다. 안전 장치는 안 바꾼다 (ui/level.js)
+    this.level = normLevel(level) ?? LEVEL_DEFAULT;
+    this.think = think;      // 기준 강도
+    this.effort = effort;    // 그 강도를 단계별로 어떻게 나눌지 (effort.js)
+    this.web = web;          // 웹 읽기 도구를 줄지 (오프라인이면 무조건 안 준다)
     this.maxSteps = maxSteps;
     this.messages = [];
     this.filesRead = new Map();   // 경로 → 추정 토큰
@@ -56,6 +63,10 @@ export class Session {
   systemPrompt() {
     const parts = [BASE_RULES];
     parts.push(`\n작업 폴더: ${this.root}\n이 폴더 밖의 파일은 읽지도 쓰지도 못한다.`);
+
+    // 지금 무슨 일을 하는 중인지. 도구 목록도 이 모드에 맞춰 이미 걸러져 있다.
+    const w = workMode(this.work);
+    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();
     if (listed.length) {

package/src/agent/sessionui.js

@@ -0,0 +1,59 @@
+// deel sessions — 이 폴더에 남아 있는 대화 목록.
+import { c, say, rule, pad, mark, clip, width } from '../ui/ansi.js';
+import { list, remove, sessionsDir } from './store.js';
+import { existsSync } from 'node:fs';
+
+// "3분 전", "어제" 처럼. 목록에서는 절대 시각보다 이쪽이 눈에 잘 들어온다.
+function 언제(d) {
+  const s = Math.floor((Date.now() - d.getTime()) / 1000);
+  if (s < 60) return '방금';
+  if (s < 3600) return `${Math.floor(s / 60)}분 전`;
+  if (s < 86400) return `${Math.floor(s / 3600)}시간 전`;
+  if (s < 172800) return '어제';
+  if (s < 604800) return `${Math.floor(s / 86400)}일 전`;
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+export function runSessions(flags = {}) {
+  const root = flags.root ? String(flags.root) : process.cwd();
+
+  if (flags.rm || flags.delete) {
+    const id = String(flags.rm ?? flags.delete);
+    const r = remove(root, id);
+    say('');
+    say(r.error ? `  ${mark.no} ${r.error}` : `  ${mark.ok} 지웠습니다: ${c.bold(r.removed)}`);
+    say('');
+    return r.error ? 1 : 0;
+  }
+
+  const rows = list(root, { limit: flags.all ? 1000 : 20 });
+  say('');
+  rule('이 폴더의 대화', 78);
+  say(`  ${c.gray(root)}`);
+  say('');
+
+  if (!rows.length) {
+    say(`  ${c.gray('남아 있는 대화가 없습니다.')}`);
+    if (!existsSync(sessionsDir(root))) {
+      say(`  ${c.gray('이 폴더에서 deel 을 한 번 쓰면 여기에 쌓입니다.')}`);
+    }
+    say('');
+    return 0;
+  }
+
+  const wId = Math.max(...rows.map((r) => width(r.id)));
+  for (const [i, r] of rows.entries()) {
+    const 최근 = i === 0 ? c.hgreen('●') : c.gray('·');
+    say(`  ${최근} ${c.bold(pad(r.id, wId))}  ${c.gray(pad(언제(r.at), 9))}`
+      + `${c.gray(pad(`${r.turns}턴`, 6, 'right'))}  ${c.gray(pad(clip(r.model, 22), 24))}`);
+    say(`    ${c.gray('  ')}${clip(r.first, 68)}`);
+  }
+  say('');
+  say(`  ${c.gray('가장 최근 것 이어하기')}   ${c.cyan('deel --continue')}`);
+  say(`  ${c.gray('골라서 이어하기')}         ${c.cyan(`deel --resume ${rows[0].id}`)}`);
+  say(`  ${c.gray('하나 지우기')}             ${c.cyan(`deel sessions --rm ${rows.at(-1).id}`)}`);
+  say('');
+  say(`  ${c.gray(`저장 위치: ${sessionsDir(root)}  (.gitignore 에 들어 있어 깃에 안 올라갑니다)`)}`);
+  say('');
+  return 0;
+}