deel-local-cli 0.5.0 → 0.9.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.effectiveWork(),                // 작업 모드가 쓰는 것만 (modes.js)
+  });
+  // 모드마다 생각의 배분과 걸음 수가 다르다. 사용자가 따로 정했으면 그걸 존중한다.
+  const 모드 = workMode(session.effectiveWork());
+  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,252 @@
+// 작업 모드. 지금 무슨 일을 하는 중인지에 따라 도구·추론·말투를 한꺼번에 바꾼다.
+//
+// 승인 정책(auto/confirm/strict)과는 다른 축이다. 헷갈리면 안 된다.
+//   승인 정책 = 얼마나 물어보나
+//   작업 모드 = 무슨 일을 하는 중인가
+// 둘은 곱해진다. '설계 모드 + strict' 도, '코드 모드 + auto' 도 말이 된다.
+//
+// 왜 도구를 아예 빼는가:
+//   설계 모드에서 파일을 고치면 안 된다고 프롬프트로 부탁할 수도 있다.
+//   그런데 모델은 부탁을 잊는다. 아예 목록에서 빼면 잊을 것이 없다.
+//   오프라인일 때 웹 도구를 숨기는 것과 같은 방식이다.
+
+// 읽기만 하는 도구. 무엇을 바꾸지 않는다.
+const 읽기 = ['Read', 'Glob', 'Grep', 'WebFetch', 'Skill'];
+// 계획을 적는 도구. 파일을 안 건드리므로 읽기 전용 모드에서도 준다.
+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: '코드',
+    en: 'Code',
+    glyph: '◆',
+    hint: '고치고 만든다',
+    tools: [...읽기, ...계획, ...쓰기],
+    effort: 'save',            // 첫 판단만 세게, 이어가기는 얕게
+    think: null,               // 사용자가 정한 값을 그대로 쓴다
+    steps: 24,
+    say: [
+      "지금 하는 일은 **구현**이다. 아래 순서를 지켜라.",
+      "",
+      "1. 고칠 파일을 먼저 Read 로 읽는다. 안 읽고 고치려 하면 도구가 거절한다.",
+      "2. 주변 코드의 관례를 따른다 — 이름 짓는 법, 오류 다루는 법, 주석 밀도까지.",
+      "   새 관례를 들여오지 마라. 이 코드가 이미 하고 있는 대로 한다.",
+      "3. 한 번에 하나씩 고친다. 여러 파일에 흩뿌리지 마라.",
+      "4. 고친 뒤에는 확인할 방법이 있으면 실제로 돌려 본다 (검사·빌드·실행).",
+      "   확인 못 했으면 \"확인 못 했다\" 고 말한다. 됐다고 하지 마라.",
+      "5. 끝나면 무엇을 왜 바꿨는지 한두 줄로 말한다. 코드를 통째로 붙여넣지 마라.",
+    ].join('\n'),
+  },
+
+  architect: {
+    id: 'architect',
+    name: '설계',
+    en: 'Architect',
+    glyph: '◈',
+    hint: '구조를 짠다 · 파일은 안 건드림',
+    tools: [...읽기, ...계획],
+    effort: 'deep',
+    think: 'high',
+    steps: 20,
+    say: [
+      "지금 하는 일은 **설계**다. 파일을 바꾸는 도구는 주어지지 않았다.",
+      "",
+      "먼저 읽어라. 지금 구조를 모르면 설계가 아니라 상상이다.",
+      "  - 관련된 파일을 Glob/Grep 으로 찾고 Read 로 실제로 읽는다",
+      "  - 무엇이 무엇에 기대고 있는지(의존 방향)를 파악한다",
+      "",
+      "그 다음 이 차례로 답한다.",
+      "  1. 지금 구조 — 파일과 역할, 경계가 어디인지 (경로:줄 로 짚어라)",
+      "  2. 무엇이 문제인가 — 왜 지금 모양으로는 안 되는지",
+      "  3. 선택지 2~3개 — 각각 무엇을 얻고 무엇을 잃는지, 손이 얼마나 가는지",
+      "  4. 추천 하나와 그 이유, 버린 것을 왜 버렸는지",
+      "  5. 영향받는 파일 목록",
+      "",
+      "이 코드가 이미 쓰는 관례 안에서 답을 찾아라. 새 틀을 들여오는 것은 마지막",
+      "수단이고, 그때는 왜 기존 관례로 안 되는지를 먼저 밝혀라.",
+    ].join('\n'),
+  },
+
+  ask: {
+    id: 'ask',
+    name: '묻기',
+    en: 'Ask',
+    glyph: '◇',
+    hint: '설명만 · 아무것도 안 바꿈',
+    tools: [...읽기],
+    effort: 'even',
+    think: 'low',
+    steps: 8,
+    say: [
+      "지금 하는 일은 **설명**이다. 아무것도 바꾸지 않는다.",
+      "",
+      "- 근거를 파일에서 대라. 경로와 줄 번호를 같이 적어라 (src/a.js:42).",
+      "- 모르면 모른다고 하라. 그럴듯한 답을 지어내지 마라.",
+      "- 짧게, 물어본 것에만 답하라.",
+      "- 고치라는 말이 없으면 고칠 것을 제안하지 마라. 시키지 않은 일을 벌이지 마라.",
+    ].join('\n'),
+  },
+
+  debug: {
+    id: 'debug',
+    name: '디버그',
+    en: 'Debug',
+    glyph: '◉',
+    hint: '원인을 찾는다',
+    tools: [...읽기, ...계획, ...쓰기],
+    effort: 'deep',
+    think: 'high',
+    steps: 32,               // 원인 찾기는 왔다 갔다 하므로 여유를 준다
+    say: [
+      "지금 하는 일은 **원인 찾기**다. 짐작으로 고치지 마라.",
+      "",
+      "이 순서를 지켜라.",
+      "  1. 증상을 한 문장으로 다시 적는다 — 무엇을 했을 때 무엇이 일어나는가.",
+      "  2. 재현 방법을 확보한다. 없으면 만든다. 재현 못 하면 고쳤는지도 알 수 없다.",
+      "  3. 가설을 2~3개 세운다. 각각 \"이게 맞다면 무엇이 보여야 하는가\" 를 같이 적는다.",
+      "  4. 하나씩 실제로 확인한다 — 로그를 보고, 작게 돌려 보고, 값을 찍어 본다.",
+      "     확인한 것만 사실이다. 확인 안 한 것은 아직 가설이다.",
+      "  5. 원인을 짚을 때는 증거를 같이 댄다. \"아마\" 로 시작하는 원인은 원인이 아니다.",
+      "  6. 고친 뒤 2번의 재현 절차로 다시 확인한다. 안 고쳐졌으면 3번으로 돌아간다.",
+      "",
+      "한 번에 여러 곳을 고치지 마라. 무엇이 고쳤는지 알 수 없게 된다.",
+    ].join('\n'),
+  },
+
+  plan: {
+    id: 'plan',
+    name: '계획',
+    en: 'Plan',
+    glyph: '☰',
+    hint: '먼저 계획 · 승인 뒤 실행',
+    tools: [...읽기, ...계획],
+    effort: 'deep',
+    think: 'high',
+    steps: 16,
+    say: [
+      "지금 하는 일은 **계획 세우기**다. 파일을 바꾸는 도구는 주어지지 않았다.",
+      "코드를 고치려 들지 마라. 계획을 내고 멈춘다.",
+      "",
+      "먼저 확인하라 — 지금 무엇이 어떻게 되어 있는지 모르면 계획이 아니라 희망이다.",
+      "  Glob/Grep 으로 관련 파일을 찾고, Read 로 실제로 읽어라.",
+      "",
+      "그 다음 이 차례로 적어라.",
+      "  1. 목표 — 무엇이 끝나면 다 된 것인가 (확인할 수 있는 문장으로)",
+      "  2. 지금 상태 — 관련된 파일과 지금 동작 (경로:줄 로 짚어라)",
+      "  3. 바꿀 것 — 파일별로 무엇을 왜",
+      "  4. 순서 — 단계별로. 각 단계는 따로 확인할 수 있는 크기로 쪼개라",
+      "  5. 위험 — 무엇이 깨질 수 있고, 깨지면 어떻게 되돌리는가",
+      "  6. 확인 방법 — 무엇을 돌려 보면 됐는지 알 수 있는가",
+      "",
+      "단계는 TodoWrite 로도 적어라. 승인 뒤 그대로 이어서 하게 된다.",
+      "모르는 것이 있으면 지어내지 말고 \"이건 확인이 필요하다\" 고 적어라.",
+      "",
+      "마지막에 \"이대로 진행할까요?\" 로 끝내라. 승인을 받으면 /code 로 바꿔 실행한다.",
+    ].join('\n'),
+  },
+
+  orchestrator: {
+    id: 'orchestrator',
+    name: '총괄',
+    en: 'Orchestrator',
+    glyph: '❋',
+    hint: '큰 일을 쪼개서 끝까지',
+    tools: [...읽기, ...계획, ...쓰기],
+    effort: 'save',
+    think: null,
+    steps: 40,               // 여러 갈래를 끝까지 끌고 가야 한다
+    say: [
+      "지금 하는 일은 **큰 일을 끝까지 끌고 가기**다.",
+      "",
+      "  1. 시작하자마자 TodoWrite 로 전체를 단계로 쪼개 적어라. 머릿속에만 두지 마라.",
+      "     단계는 각각 따로 확인할 수 있는 크기여야 한다.",
+      "  2. 한 번에 하나만 진행 중으로 둬라. 끝나면 바로 표시하고 다음으로 넘어가라.",
+      "  3. 각 단계 끝에서 확인하라. 확인 없이 넘어가면 어디서 어긋났는지 못 찾는다.",
+      "  4. 막히면 멈추고 무엇에 막혔는지 보고하라. 우회로를 몰래 타지 마라.",
+      "  5. 계획이 틀린 것을 알게 되면 목록을 고쳐라. 틀린 계획을 끝까지 밀지 마라.",
+      "",
+      "다 끝나면 무엇을 했는지, 무엇을 못 했는지 같이 요약하라.",
+      "못 한 것을 빼고 요약하지 마라.",
+    ].join('\n'),
+  },
+};
+
+export const ORDER = ['auto', 'code', 'plan', 'architect', 'debug', 'ask', 'orchestrator'];
+export const DEFAULT = 'auto';
+
+/** 이름을 관대하게 받는다. 한글·영문·줄임말 다 통한다. */
+export function normalize(v) {
+  const s = String(v ?? '').trim().toLowerCase();
+  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',
+    '디버그': '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));
+}