deel-local-cli 1.2.0 → 1.4.1

package/src/agent/compact.js

@@ -84,6 +84,12 @@ export function foldToolResults(session, { keep = KEEP_RECENT, min = FOLD_MIN }
 
   const 접을것 = 자리.slice(0, Math.max(0, 자리.length - keep)).filter((x) => x.글.length >= min);
   let 아낀토큰 = 0;
+  // 무엇을 버렸는지 이름으로 남긴다.
+  //
+  // 조용히 버리면 사람이 모른다 — "아까 그 파일 내용 어디 갔지" 를 스스로 답할
+  // 길이 없다. 접힌 자리에 표시가 남긴 하지만 그건 모델이 보는 쪽이고,
+  // 사람 화면에는 여기서 돌려주는 목록으로 알려 준다.
+  const 접은것들 = [];
 
   for (const { i, 글 } of 접을것) {
     const m = ms[i];
@@ -96,10 +102,12 @@ export function foldToolResults(session, { keep = KEEP_RECENT, min = FOLD_MIN }
       content: `${접힘표} ${아는것.name}${곳 ? `(${곳})` : ''} — ${줄수}줄. `
         + '자리를 비우려고 내용을 접었습니다. 필요하면 다시 읽으세요.',
     };
-    아낀토큰 += 전 - estimateTokens(ms[i].content);
+    const 아낀것 = 전 - estimateTokens(ms[i].content);
+    아낀토큰 += 아낀것;
+    접은것들.push({ 도구: 아는것.name, 곳, 줄수, 토큰: Math.max(0, 아낀것) });
   }
 
-  return { 접은것: 접을것.length, 아낀토큰: Math.max(0, 아낀토큰) };
+  return { 접은것: 접을것.length, 아낀토큰: Math.max(0, 아낀토큰), 접은것들 };
 }
 
 const 요약지시 = `지금까지의 대화를 다음 형식으로 요약하세요. 이어서 일할 사람이 이것만 보고도 계속할 수 있어야 합니다.

package/src/agent/effort.js

@@ -36,18 +36,23 @@ export const STAGES = {
 export const PROFILES = {
   even: {
     name: '균일',
+    // 화면 말이 영어일 때 쓰는 이름. modes.js 의 en 과 같은 방식이다 —
+    // i18n 표에 같은 말을 또 적어 두면 언젠가 둘이 갈라진다.
+    en: 'even',
     desc: '모든 단계 같은 강도 — 예측 가능한 대신 느립니다',
     shift: { plan: 0, work: 0, fix: 0 },
     share: { plan: 0.40, work: 0.40, fix: 0.40 },
   },
   save: {
     name: '절약',
+    en: 'save',
     desc: '첫 판단만 세게, 이어가기는 얕게 — 대개 이게 낫습니다',
     shift: { plan: 0, work: -1, fix: +1 },
     share: { plan: 0.40, work: 0.35, fix: 0.45 },
   },
   deep: {
     name: '깊게',
+    en: 'deep',
     desc: '전 단계 한 칸씩 위로 — 어려운 일에만',
     shift: { plan: +1, work: 0, fix: +1 },
     share: { plan: 0.50, work: 0.45, fix: 0.50 },

package/src/agent/evidence.js

@@ -0,0 +1,186 @@
+// 증거 — 「다 됐습니다」 대신 검토할 수 있는 것을 내놓는다.
+//
+// ── 왜 만드나 ───────────────────────────────────────────────────────────
+//
+// 2026년 조사로는 개발자의 **96%가 AI 가 쓴 코드를 온전히 믿지 않는데, 매번
+// 확인하는 사람은 48%** 다. 38%는 "사람 코드보다 리뷰가 더 힘들다"고 답한다.
+//
+// 왜 더 힘든가. 사람이 낸 코드는 "왜 이렇게 했나" 를 물으면 답이 온다. 에이전트가
+// 낸 코드는 **"끝났습니다" 한 줄**과 함께 온다. 그 한 줄은 검토할 수가 없다.
+// 무엇을 근거로 끝났다고 하는지가 그 안에 없기 때문이다.
+//
+// 그래서 이 파일이 하는 일은 하나다 — **말을 증거로 바꾼다.**
+//
+//   무엇을 바꿨나   파일과 줄 수
+//   무엇을 돌렸나   명령과 그 결과
+//   무엇이 증명됐나 고친 **뒤에** 돌아서 **성공한** 것이 있는가
+//
+// ── 제일 중요한 칸 ──────────────────────────────────────────────────────
+//
+// 바꾼 것을 늘어놓는 일은 /diff 도 한다. 여기서만 하는 것은 **증명 안 된 것**을
+// 증명 안 됐다고 말하는 것이다.
+//
+// 고쳐 놓고 아무것도 안 돌렸으면 아무것도 증명되지 않았다. 검사가 빨간데
+// 돌리기는 했다고 초록으로 치면 그건 **빨간 검사를 증거로 내미는** 셈이다.
+// 고치기 **전에** 돌린 검사는 고친 것을 증명하지 못한다 — "아까 돌렸으니 됐다" 가
+// 제일 흔한 자기기만이다. 셋 다 여기서 걸러진다.
+//
+// ── 안 하는 것 ──────────────────────────────────────────────────────────
+//
+// 프롬프트에 안 싣는다. 이건 사람이 보는 것이지 모델에게 먹이는 것이 아니다.
+// 실으면 컨텍스트만 먹고, 모델이 제가 만든 증거를 다시 읽는 이상한 고리가 생긴다.
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** 이 명령들은 '확인했다' 로 친다. 돌렸다고 다 증거가 되는 것은 아니다. */
+const 확인하는명령 = /(^|[\s|;&])(npm|pnpm|yarn|bun)\s+(test|run\s+(test|check|lint|build|verify|typecheck))|(^|[\s|;&])(pytest|jest|vitest|mocha|go\s+test|cargo\s+test|mvn\s+test|gradle\s+test|dotnet\s+test|tsc|eslint|ruff|mypy)\b/i;
+
+/** 우리 쪽 확인 도구. Bash 를 안 거치고 확인하는 길이다. */
+const 확인하는도구 = new Set(['Verify', 'Test']);
+
+/**
+ * 이번 대화의 증거를 모은다.
+ *
+ * @param {object} session
+ * @param {object} o
+ * @param {object} o.audit      safety/audit.js 의 Audit
+ * @param {number} o.최근       감사기록을 몇 줄까지 볼까
+ * @param {Date}   o.바꾼때     파일을 언제 고쳤다고 볼까 (검사가 고정할 수 있게)
+ */
+export function 증거모으기(session, { audit = null, 최근 = 400, 바꾼때 = null } = {}) {
+  /*
+   * 감사기록은 폴더에 하나뿐이고 계속 덧붙는다. 그대로 읽으면 **지난주에 돌린
+   * 검사**가 오늘 고친 파일의 증거로 붙는다 — 증거를 모으는 도구가 거짓 증거를
+   * 만드는 셈이다. 이번 세션 것만 본다.
+   */
+  const 이번세션 = audit?.session ?? null;
+  const 기록 = (() => {
+    try {
+      const 전부 = audit?.recent?.(최근) ?? [];
+      return 이번세션 ? 전부.filter((r) => r?.session === 이번세션) : 전부;
+    } catch { return []; }
+  })();
+
+  // 돌린 것 — Bash 와 확인 도구만. 파일을 읽은 것까지 증거라고 하면 목록이
+  // 길어지기만 하고, 읽은 것은 아무것도 증명하지 않는다.
+  const 돌린것 = [];
+  for (const r of 기록) {
+    if (r?.kind !== 'tool') continue;
+    const 도구 = String(r.tool ?? '');
+    if (도구 !== 'Bash' && !확인하는도구.has(도구)) continue;
+    돌린것.push({
+      도구,
+      무엇: String(r.target ?? ''),
+      됐나: r.ok !== false,
+      남긴말: r.ok === false ? `실패 — ${String(r.note ?? '').slice(0, 120)}` : String(r.note ?? '').slice(0, 120),
+      때: r.at ?? null,
+      확인인가: 확인하는도구.has(도구) || 확인하는명령.test(String(r.target ?? '')),
+    });
+  }
+
+  const 확인시도 = 돌린것.filter((x) => x.확인인가);
+  const 언제고쳤나 = 바꾼때 ? new Date(바꾼때).getTime() : null;
+
+  const 바꾼것 = [];
+  const 증명안된것 = [];
+  for (const [파일, d] of session?.changes ?? new Map()) {
+    // 고친 **뒤에** 돌린 확인만 본다.
+    const 쓸것 = 확인시도.filter((x) => {
+      if (언제고쳤나 == null || !x.때) return true;   // 시각을 모르면 순서를 안 따진다
+      return new Date(x.때).getTime() >= 언제고쳤나;
+    });
+    /*
+     * **마지막** 확인이 증거다. 성공한 것 중 마지막이 아니다.
+     *
+     * 빌드가 통과하고 그 뒤에 검사가 깨졌는데 앞의 초록을 들고 와서
+     * "확인됐습니다" 하면 그게 거짓 증거다. 사람이 보는 순서로 생각하면
+     * 답이 분명하다 — 마지막에 돌린 것이 빨간데 확인됐을 리가 없다.
+     */
+    const 마지막 = 쓸것.length ? 쓸것[쓸것.length - 1] : null;
+    const 증명 = 마지막?.됐나 ? 마지막.무엇 : null;
+    const 한줄 = { 파일, 더한줄: d.added ?? 0, 뺀줄: d.removed ?? 0, 고친횟수: d.times ?? 0, 증명 };
+    바꾼것.push(한줄);
+    if (!증명) {
+      증명안된것.push({
+        파일,
+        왜: 왜못믿나(돌린것, 마지막, 언제고쳤나),
+      });
+    }
+  }
+
+  return {
+    바꾼것,
+    돌린것,
+    증명안된것,
+    // 화면이 한눈에 쓸 수 있게 미리 세어 둔다.
+    셈: {
+      파일: 바꾼것.length,
+      더한줄: 바꾼것.reduce((a, x) => a + x.더한줄, 0),
+      뺀줄: 바꾼것.reduce((a, x) => a + x.뺀줄, 0),
+      돌린것: 돌린것.length,
+      실패한것: 돌린것.filter((x) => !x.됐나).length,
+      증명안됨: 증명안된것.length,
+    },
+  };
+}
+
+function 왜못믿나(돌린것, 마지막, 언제고쳤나) {
+  if (!돌린것.length) return '고친 뒤에 아무것도 안 돌렸습니다 — 무엇도 확인되지 않았습니다.';
+  const 확인시도 = 돌린것.filter((x) => x.확인인가);
+  if (!확인시도.length) return '명령은 돌렸지만 검사·빌드는 안 돌렸습니다.';
+  if (마지막 && !마지막.됐나) {
+    return `마지막으로 돌린 \`${마지막.무엇}\` 이 실패했습니다 — 그 앞이 통과했어도 지금 상태를 증명하지 못합니다.`;
+  }
+  if (!마지막 && 언제고쳤나 != null) return '검사가 이 파일을 고치기 전에 돌았습니다 — 그 뒤 바뀐 것은 확인되지 않았습니다.';
+  return '확인되지 않았습니다.';
+}
+
+/** 사람이 읽고 남길 수 있는 글. 마크다운. */
+export function 증거글(증거, { 제목 = '작업 증거' } = {}) {
+  const e = 증거 ?? {};
+  const 줄 = [`# ${제목}`, ''];
+
+  줄.push('## 바꾼 것', '');
+  if (!e.바꾼것?.length) 줄.push('바꾼 파일이 없습니다.', '');
+  else {
+    줄.push('| 파일 | 더함 | 뺌 | 확인한 것 |', '|---|---|---|---|');
+    for (const x of e.바꾼것) {
+      줄.push(`| ${x.파일} | +${x.더한줄} | -${x.뺀줄} | ${x.증명 ? `\`${x.증명}\`` : '**없음**'} |`);
+    }
+    줄.push('');
+  }
+
+  줄.push('## 돌린 것', '');
+  if (!e.돌린것?.length) 줄.push('돌린 명령이 없습니다.', '');
+  else {
+    for (const x of e.돌린것) {
+      줄.push(`- ${x.됐나 ? '✓' : '✗'} \`${x.무엇}\`${x.남긴말 ? ` — ${x.남긴말}` : ''}`);
+    }
+    줄.push('');
+  }
+
+  // 이 절이 이 글의 요점이다. 비어 있으면 비어 있다고 분명히 적는다.
+  줄.push('## 증명 안 된 것', '');
+  if (!e.증명안된것?.length) 줄.push('없습니다 — 바꾼 것마다 뒤에 돌린 확인이 있습니다.', '');
+  else {
+    for (const x of e.증명안된것) 줄.push(`- **${x.파일}** — ${x.왜}`);
+    줄.push('');
+  }
+
+  return 줄.join('\n');
+}
+
+/**
+ * 파일로 남긴다. 화면은 스크롤로 사라지고, 검토는 나중에 다른 사람이 한다.
+ *
+ * @returns {string|null} 적은 자리. 못 적었으면 null — 못 적어도 대화는 계속된다.
+ */
+export function 증거적기(root, 증거, 이름 = '증거') {
+  try {
+    const dir = join(root, '.deel', '증거');
+    mkdirSync(dir, { recursive: true });
+    const 자리 = join(dir, `${String(이름).replace(/[^\w가-힣.-]/g, '_')}.md`);
+    writeFileSync(자리, 증거글(증거), 'utf8');
+    return 자리;
+  } catch { return null; }
+}

package/src/agent/grade.js

@@ -1,3 +1,4 @@
+import { 언어 } from '../i18n/index.js';
 /**
  * 모델 급 — 지금 붙어 있는 모델이 얼마나 하는가.
  *
@@ -194,7 +195,26 @@ export function 값(급) {
 export function 급말(급) {
   const v = 값(급);
   if (급 === '큼') return '';
+  /*
+   * 이 글도 모델이 읽는 것이라 화면 말을 따라간다.
+   *
+   * 안 따라가면 영어로 켠 사람의 작은 모델만 한국어 지시를 받는데, 하필
+   * 그 조합이 제일 흔들리기 쉽다 — 작은 모델은 못 읽는 말이 섞이면 그 줄을
+   * 통째로 흘린다. 지시가 있는 척하면서 실제로는 없는 상태가 된다.
+   */
+  const 영 = 언어() === 'en';
   const 줄 = [];
+  if (영) {
+    줄.push('Sized to this model:');
+    줄.push(`- Create at most ${v.한번에쓸파일} files in one Write call. More than that, split it across calls.`);
+    줄.push(`- For a file over ${v.나눠쓰기줄} lines, Write the first part and Append the rest.`);
+    if (급 === '작음') {
+      줄.push('- One thing per step. Do not call several tools at once.');
+      줄.push('- Edit a file on the **very next step** after you Read it. Do not put anything in between.');
+    }
+    줄.push('- Call Verify before you finish. Fix what comes back and call it again.');
+    return 줄.join('\n');
+  }
   줄.push('이 모델에 맞춘 것:');
   줄.push(`- 파일을 한 번에 만들 때는 ${v.한번에쓸파일}개까지만. 더 있으면 나눠서 여러 번 불러라.`);
   줄.push(`- ${v.나눠쓰기줄}줄이 넘는 파일은 Write 로 앞부분만 만들고 Append 로 이어 붙여라.`);

package/src/agent/loop.js

@@ -10,7 +10,9 @@ import { compact, shouldCompact, shouldFold, foldToolResults } from './compact.j
 import { 걸음수, 하위걸음수, 요약길이 } from './budget.js';
 import { Session } from './session.js';
 import { 최대깊이, 하위모드, 하위요약 } from '../tools/task.js';
-import { isOffline } from '../safety/network.js';
+import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './models.js';
+import { allowTemporarily, isOffline } from '../safety/network.js';
+import { 가리기, 훑기, 가렸다는말, 봤다는말, 가릴도구 } from '../safety/secrets.js';
 import { get as workMode } from './modes.js';
 
 /**
@@ -57,16 +59,20 @@ export function 묶기(calls) {
 }
 
 export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 } = {}) {
-  session.push({ role: 'user', content: userText });
-  ctx.audit.turn(깊이 ? `[하위작업 ${깊이}겹] ${userText}` : userText);
   /*
    * 되돌리기 턴은 **부모만** 연다.
    *
    * 하위 작업이 제 턴을 열면 `/undo` 한 번이 하위가 만든 것만 되돌리고
    * 부모가 만든 것은 남긴다 — 반쪽만 되돌아간 폴더가 된다. 사람 눈에는
    * 한 번 시킨 일이니 한 번에 되돌아가야 맞다.
+   *
+   * 턴을 **사람 말을 넣기 전에** 연다. 그래야 그 말 자체가 이 턴의 첫 말로
+   * 표시되고, 되감을 때 시킨 말까지 같이 걷힌다. 시킨 말만 남으면 모델은
+   * 되돌린 일을 또 하려 든다.
    */
-  if (!깊이) ctx.history.nextTurn();
+  if (!깊이) session.턴시작(ctx.history.nextTurn());
+  session.push({ role: 'user', content: userText });
+  ctx.audit.turn(깊이 ? `[하위작업 ${깊이}겹] ${userText}` : userText);
 
   /*
    * 중단 신호를 도구도 볼 수 있게 여기 걸어 둔다.
@@ -95,7 +101,15 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
    * '헛도는 작업' 을 구분하지 못한다. 여기서는 같은 자리를 반복하는 것만 본다.
    */
   const 막힘 = new Map();
-  const MAX_SAME = 3;
+  /*
+   * 몇 번까지 봐 줄까는 **이 모델을 겪어 본 만큼** 정한다 (agent/card.js).
+   *
+   * 되풀이가 버릇인 모델에서는 세 번까지 기다릴 이유가 없다. 되풀이한 만큼
+   * 컨텍스트가 차고 그만큼 요약이 빨리 온다 — 걸음만 태우는 것이 아니다.
+   * 겪은 것이 모자라면 여태 쓰던 3 그대로다.
+   */
+  const 이카드 = ctx?.카드 ?? null;
+  const MAX_SAME = 이카드?.조정?.같은것한계 ?? 3;
   let 멈출까 = null;
   const 막힘셈 = (call, 이유) => {
     // 파일 하나가 아니라 **그 파일** 을 센다. 이름만 세면 서로 다른 파일 세 개를
@@ -194,6 +208,9 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
     work: session.effectiveWork(),                // 작업 모드가 쓰는 것만 (modes.js)
     // 밖에서 붙인 도구(MCP). 붙은 것이 없으면 아무것도 안 는다.
     mcp: ctx.mcp ?? null,
+    // 이 자리에 언어 서버가 있을 때만 Def·Refs 를 보여 준다 (tools/lsp.js).
+    // 없는 자리에서 목록에 세워 두면 모델이 부르고, 실패를 받고, 또 부른다.
+    lsp: session.lsp === true,
     // 창이 좁으면 도구 설명을 줄여 싣는다 (budget.js 의 설명길이).
     // 도구를 빼는 게 아니라 설명만 줄이므로 할 수 있는 일은 안 달라진다.
     ctx: conn.ctx ?? null,
@@ -248,7 +265,16 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
     // 출력 상한을 아는 값이 둘 있다 — 사용자가 정한 것(/out)과 서버에서 알아낸 것.
     // 사람이 정한 것이 먼저다. 둘 다 없으면 null 이고, 그때만 effort.js 의 MAX_CAP 에 선다.
     const room = { ctx: conn.ctx ?? 0, used: session.breakdown().used, max: conn.maxTokens ?? conn.maxOut ?? null };
-    const cap = tokensFor(effort, stage, room);
+    /*
+     * 이 모델이 인자를 자주 잘라 먹는다면 처음부터 넉넉히 준다 (agent/card.js).
+     *
+     * 지금은 잘린 **뒤에야** 상한을 올려 다시 부른다. 한 번은 반드시 버리는 셈이다.
+     * 잘리는 것이 이 모델의 버릇으로 재어졌다면 그 한 번을 매번 버릴 이유가 없다.
+     * 상한은 최댓값이지 정해진 길이가 아니라서, 짧게 답하는 턴에는 값이 안 든다.
+     */
+    const cap = 이카드?.조정?.상한먼저올리기
+      ? Math.max(tokensFor(effort, stage, room), fullCap(room))
+      : tokensFor(effort, stage, room);
     yield { type: 'stage', stage, level, cap, step: steps };
 
     const ask = (maxTokens, think) => ({
@@ -592,7 +618,43 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         }
 
         const 자식모드 = 하위모드(call.args?.모드 ?? call.args?.mode, 모드.id);
-        const 자식 = new Session(conn, {
+
+        /*
+         * ── 다른 모델에게 떼어 주기 ─────────────────────────────────────
+         *
+         * 안 적으면 지금 쓰는 것 그대로다. 적었으면 **사람이 설정에 적어 둔
+         * 프로필**에서만 찾는다 — 모델이 주소를 지어내면 그 자리로 나갈 뻔하고,
+         * 그건 이 프로그램이 하는 약속을 그 자리에서 깨는 것이다.
+         *
+         * 못 찾으면 조용히 지금 모델로 돌지 않는다. 시킨 쪽은 작은 모델에게
+         * 넘긴 줄 알고 창을 아끼고 있는데 실제로는 큰 모델이 다 받는 셈이라,
+         * 원인을 못 찾는 쪽으로 어긋난다. 무엇이 있는지 적어 되돌려 준다.
+         */
+        let 자식conn = conn;
+        let 자리닫기 = null;
+        let 모델알림 = null;
+        const 부른모델 = String(call.args?.모델 ?? call.args?.model ?? '').trim();
+        if (부른모델) {
+          const 찾음 = 프로필찾기(부른모델);
+          if (!찾음.ok) {
+            const 있는것 = 목록보기().map((x) => x.id).join(' · ') || '(설정에 프로필이 없습니다)';
+            거절(call, `${찾음.why}. 쓸 수 있는 이름: ${있는것}`);
+            yield { type: 'tool', name: 'Task', args: call.args, result: { error: 찾음.why }, showLabel: true };
+            continue;
+          }
+          const 되나 = 쓸수있나(찾음.prof);
+          if (!되나.ok) {
+            거절(call, `${부른모델} 은 지금 못 씁니다 — ${되나.why}`);
+            yield { type: 'tool', name: 'Task', args: call.args, result: { error: 되나.why }, showLabel: true };
+            continue;
+          }
+          자식conn = 연결만들기(찾음.prof);
+          모델알림 = 알릴말(conn, 자식conn);
+          // 그 일이 도는 동안만 연다. 끝나면 반드시 닫는다 — 아래 finally.
+          if (모델알림.다른자리) 자리닫기 = allowTemporarily(자식conn.base);
+        }
+
+        const 자식 = new Session(자식conn, {
           root: session.root,
           // 승인 방식은 그대로 물려준다. 하위가 승인을 우회하면 strict 가 거짓말이 된다.
           mode: session.mode,
@@ -604,7 +666,9 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
           // 부모보다 적게 준다 (budget.js). 사람이 직접 정한 값이 있으면 그 절반.
           maxSteps: session.stepsSet
             ? Math.max(4, Math.floor(session.maxSteps / 2))
-            : 하위걸음수(자식모드, conn.ctx),
+            // 걸음 수는 **하위가 쓸 창**으로 잰다. 부모 창으로 재면, 작은 모델에게
+            // 떼어 준 일이 제 창보다 큰 걸음 수를 받아 중간에 창이 찬 채로 돈다.
+            : 하위걸음수(자식모드, 자식conn.ctx),
         });
         // 스킬·명령·기억은 부모가 켤 때 한 번 찾아 든 것이다. 하위도 같은 것을 본다.
         자식.skills = session.skills;
@@ -622,8 +686,19 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
          * 미리 +1 을 해 두면 두 겹째에서 1이 두 번 붙어 3이 된다.
          * 경계선은 부모 자리에 그어야 어디부터가 떼어 낸 일인지 보인다.
          */
-        yield { type: 'task_start', 목적, 모드: 자식모드, steps: 자식.maxSteps };
-        ctx.audit.tool('Task', { 목적, 모드: 자식모드 }, { summary: `하위 작업 시작 (${깊이 + 1}겹)` });
+        /*
+         * 다른 모델을 쓰면 **어디로 나가는지까지** 적는다.
+         *
+         * 조용히 여는 것이 제일 나쁘다. 상태줄의 ⌂ 는 이 세션의 연결을 보고
+         * 있어서 하위가 딴 데로 나가는 것을 모른다. 그러니 이 줄과 감사기록이
+         * 그 사실을 남기는 유일한 자리다.
+         */
+        yield {
+          type: 'task_start', 목적, 모드: 자식모드, steps: 자식.maxSteps,
+          모델: 모델알림?.말 ?? null, 밖으로: 모델알림?.밖으로 ?? false,
+        };
+        ctx.audit.tool('Task', { 목적, 모드: 자식모드, 모델: 모델알림?.말 ?? null },
+          { summary: `하위 작업 시작 (${깊이 + 1}겹)${모델알림 ? ` · ${모델알림.말}` : ''}` });
 
         let 끝 = null;
         try {
@@ -647,6 +722,10 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         } catch (err) {
           // 하위가 터져도 부모 턴은 살린다. 무엇 때문에 터졌는지는 요약에 실린다.
           끝 = { type: 'stuck', why: String(err?.message ?? err), steps: 0, files: [] };
+        } finally {
+          // 잠깐 열어 둔 자리는 무슨 일이 있어도 닫는다. 안 닫으면 그 세션이
+          // 끝날 때까지 그 주소가 열린 채로 남는다 — '한 자리만 연다' 가 깨진다.
+          try { 자리닫기?.(); } catch { /* 닫다 터져도 이번 턴은 이어간다 */ }
         }
 
         /*
@@ -664,13 +743,13 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         session.usage.ms += 자식.usage.ms;
 
         const 글 = 하위요약({
-          목적, 모드: 자식모드, 끝,
+          목적, 모드: 자식모드, 끝, 모델: 모델알림?.말 ?? null,
           글자수: 요약길이(conn.ctx),
           보인이름: (경로) => ctx.scope?.show?.(경로) ?? 경로,
         });
         session.push(toolMessage(conn.kind, { callId: call.id, name: 'Task', content: 글 }));
         ctx.audit.tool('Task', { 목적 }, { summary: 글.slice(0, 300) });
-        yield { type: 'task_done', 목적, 모드: 자식모드, 끝 };
+        yield { type: 'task_done', 목적, 모드: 자식모드, 끝, 모델: 모델알림?.말 ?? null };
 
         // 사용자가 중단했으면 부모도 여기서 멈춘다. 하위만 끊고 이어가면
         // 무엇이 중단된 것인지 알 수 없는 화면이 된다.
@@ -760,12 +839,54 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
           }
         }
 
+        /*
+         * ── 비밀 가리기 ─────────────────────────────────────────────────
+         *
+         * 여기가 도구 결과가 대화로 들어가는 **유일한** 자리다. 여기서 막으면
+         * 모델에게도 안 가고 `.deel/sessions/*.jsonl` 에도 안 적힌다. 한 번
+         * 새면 두 벌이 되는 것을 한 곳에서 끊는다.
+         *
+         * 새는 자리는 거의 항상 명령 출력이다 — env · git remote -v · curl -v ·
+         * 검사 실패 로그. 그래서 그런 도구만 가린다.
+         *
+         * 파일에서 읽어 온 글은 **안 가린다.** 가리면 모델이 가려진 글을 보고
+         * 그대로 되돌려 써서, 진짜 열쇠가 있던 자리에 표가 적힌다 — 비밀을
+         * 지키려다 비밀을 지우는 셈이다. 대신 무엇이 들어왔는지 알린다.
+         */
+        const 아는열쇠들 = [conn.key, process.env.DEEL_API_KEY].filter(Boolean);
+        let 비밀 = [];
+        if (가릴도구.has(call.name)) {
+          const 가린 = 가리기(실을것, { 열쇠들: 아는열쇠들 });
+          if (가린.가린것.length) {
+            비밀 = 가린.가린것;
+            실을것 = 가린.글 + 가렸다는말(가린.가린것);
+          }
+        } else if (result.content) {
+          // 안 고치고 보기만 한다. 사람이 알아야 손을 쓸 수 있다.
+          비밀 = 훑기(실을것, { 열쇠들: 아는열쇠들 });
+        }
+        if (비밀.length) {
+          ctx.audit?.write?.('secret', {
+            tool: call.name,
+            가렸나: 가릴도구.has(call.name),
+            무엇: 비밀.map((x) => `${x.종류}×${x.몇번}`).join(' '),
+          });
+        }
+
         session.push(toolMessage(conn.kind, {
           callId: call.id,
           name: call.name,
           content: 실을것,
         }));
-        yield { type: 'tool', name: call.name, args: call.args, result, ms, parallel: 함께 };
+        yield {
+          type: 'tool',
+          name: call.name,
+          args: call.args,
+          result,
+          ms,
+          parallel: 함께,
+          ...(비밀.length ? { 비밀: { 가렸나: 가릴도구.has(call.name), 말: 봤다는말(비밀) } } : {}),
+        };
       }
     }