deel-local-cli 1.20.13 → 2.0.1

package/src/agent/agents.js

@@ -35,6 +35,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { extname, join } from 'node:path';
 import { frontmatter } from '../skills/discover.js';
+import { BOM떼기, 믿나, 고른경로 } from '../safety/trust.js';
 
 /** 한 폴더에서 읽을 수 있는 수. 스무 개를 넘기면 목록이 프롬프트를 먹는다. */
 export const 최대 = 24;
@@ -46,6 +47,20 @@ export const 자리들 = (밑) => [join(밑, '.deel', 'agents'), join(밑, '.cla
 /** 파일 이름에서 뽑은 이름. 확장자와 경로를 뗀 것. */
 const 이름뽑기 = (파일) => 파일.replace(/\.(json|md)$/i, '').trim();
 
+/**
+ * 적힌 것 중 **처음으로 비지 않은** 것. 없으면 빈 글.
+ *
+ * `??` 는 빈 글에서 안 넘어간다. `name: ""` 한 줄이 파일 이름 대신 서던 자리가
+ * 그래서 생겼다 — 빈 이름은 안 적은 것과 같다(2.0.0 8회차).
+ */
+const 첫글 = (...것들) => {
+  for (const x of 것들) {
+    const s = String(x ?? '').trim();
+    if (s) return s;
+  }
+  return '';
+};
+
 /**
  * 정의 하나를 우리 모양으로 편다.
  *
@@ -53,11 +68,19 @@ const 이름뽑기 = (파일) => 파일.replace(/\.(json|md)$/i, '').trim();
  * 사람은 제가 만든 에이전트가 왜 안 보이는지 영영 모른다.
  */
 export function 한정의(이름, 것, 출처) {
+  const 쓸이름 = String(이름 ?? '').trim();
+  /*
+   * 이름이 없으면 안 받는다 (2.0.0 8회차 판정).
+   *
+   * 찾기() 는 빈 이름에 늘 null 을 준다 — 이름 빈 정의는 세워 봐야 영영 못 부른다.
+   * 그런데 상한(최대) 한 칸을 먹고, Task 스키마 목록에는 `(설명)` 만 덜렁 실렸다.
+   */
+  if (!쓸이름) return null;
   const 설명 = String(것?.설명 ?? 것?.description ?? '').trim();
   if (!설명) return null;      // 설명이 없으면 부모 모델이 고를 수가 없다
   const 도구 = 것?.도구 ?? 것?.tools ?? null;
   return {
-    이름: String(이름).trim(),
+    이름: 쓸이름,
     설명: 설명.length > 설명길이 ? `${설명.slice(0, 설명길이)}…` : 설명,
     모드: String(것?.모드 ?? 것?.mode ?? '').trim() || null,
     모델: String(것?.모델 ?? 것?.model ?? '').trim() || null,
@@ -84,8 +107,13 @@ function 파일하나(경로, 파일, 출처) {
   const 글 = readFileSync(경로, 'utf8');
   if (extname(파일).toLowerCase() === '.json') {
     let j;
-    try { j = JSON.parse(글); } catch (e) { return { 왜: `${파일}: JSON 이 아닙니다 — ${e.message}` }; }
-    const r = 한정의(j?.이름 ?? j?.name ?? 이름, j, 출처);
+    /*
+     * BOM 을 떼고 푼다. 파워셸 5.1 의 `Set-Content -Encoding UTF8` 이 파일 앞에 BOM 을
+     * 붙이고, 사내에서 정의를 스크립트로 까는 자리가 딱 그 명령이다. 안 떼면 그 한
+     * 글자에서 「JSON 이 아닙니다」 로 정의가 통째로 빠진다 (safety/trust.js 의 BOM떼기).
+     */
+    try { j = JSON.parse(BOM떼기(글)); } catch (e) { return { 왜: `${파일}: JSON 이 아닙니다 — ${e.message}` }; }
+    const r = 한정의(첫글(j?.이름, j?.name, 이름), j, 출처);
     return r ? { 것: r } : { 왜: `${파일}: 설명이 없습니다 (설명 · description)` };
   }
   /*
@@ -95,8 +123,20 @@ function 파일하나(경로, 파일, 출처) {
    * 이미 그 파일을 가진 사람에게 「우리 모양으로 다시 적어라」 고 하면, 그
    * 사람은 이 기능을 안 쓴다. 본문은 통째로 지침이 된다.
    */
-  const { data, body } = frontmatter(글);
-  const r = 한정의(data?.name ?? data?.이름 ?? 이름, { ...data, 지침: data?.지침 ?? body }, 출처);
+  // BOM 도 뗀다 — JSON 갈래만 떼고 있어서 BOM 붙은 .md 는 앞머리가 없는 파일로 읽혀 통째로 빠졌다(2.0.0 4회차).
+  const { data, body } = frontmatter(BOM떼기(글));
+  /*
+   * 본문이 비면 **앞머리에 적은 것**이 지침이 된다 (2.0.0 8회차 판정).
+   *
+   * 여태 `지침: data?.지침 ?? body` 였다. 앞머리만 적은 `.md`(본문이 빈 파일)에서 body 는
+   * `''` 인데, 빈 글은 nullish 가 아니라 한정의() 안의 `것?.지침 ?? 것?.prompt ?? 것?.본문`
+   * 이 거기서 멎었다 — 앞머리에 적어 둔 `prompt:` 가 조용히 버려지고, 화면에는 그
+   * 에이전트가 멀쩡히 선다. 지침 없는 하위는 아무 규칙 없이 그냥 돈다.
+   * 빈 것은 **없는 것으로** 넘겨 한정의() 가 나머지 이름들을 마저 보게 한다.
+   * 본문이 있으면 여태대로 본문이 이긴다 (머리말의 「본문은 통째로 지침이 된다」).
+   */
+  const 몸통 = 첫글(data?.지침, body) || null;
+  const r = 한정의(첫글(data?.name, data?.이름, 이름), { ...data, 지침: 몸통 }, 출처);
   return r ? { 것: r } : { 왜: `${파일}: 앞머리에 description 이 없습니다` };
 }
 
@@ -110,7 +150,18 @@ function 폴더하나(폴더, 출처, 모은것, 버린것) {
     if (모은것.size >= 최대) { 버린것.push(`${최대}개까지만 읽습니다 — ${d.name} 부터는 안 읽었습니다`); break; }
     try {
       const r = 파일하나(join(폴더, d.name), d.name, 출처);
-      if (r.것) 모은것.set(r.것.이름, r.것); else 버린것.push(r.왜);
+      /*
+       * 열쇠는 **소문자**다. 찾기() 가 대소문자를 안 가리는데 여기서 가리면, 이 PC 의
+       * `Reviewer` 와 프로젝트의 `reviewer` 가 둘 다 서고 찾기() 는 먼저 선 이 PC 것을
+       * 돌려준다 — 「가까운 쪽이 이긴다」 가 글자 크기 하나로 뒤집힌다(2.0.0 4회차).
+       * 이름 자체는 적힌 그대로 둔다. 사람이 적은 모양으로 화면에 떠야 한다.
+       *
+       * **먼저 선 것이 이긴다.** 부르는 쪽이 프로젝트 폴더부터 읽으므로(에이전트읽기)
+       * 겹치면 프로젝트가 이긴다 — 여태 「나중에 읽은 것이 덮는다」 로 같은 결과를
+       * 냈는데, 읽는 차례가 뒤집힌 지금 덮으면 이 PC 것이 이겨 규칙이 거꾸로 선다.
+       */
+      if (!r.것) 버린것.push(r.왜);
+      else if (!모은것.has(r.것.이름.toLowerCase())) 모은것.set(r.것.이름.toLowerCase(), r.것);
     } catch (e) {
       버린것.push(`${d.name}: 못 읽었습니다 — ${e.message}`);
     }
@@ -120,19 +171,60 @@ function 폴더하나(폴더, 출처, 모은것, 버린것) {
 /**
  * 이 자리에서 쓸 에이전트를 다 읽는다.
  *
- * 이 PC 것을 먼저, 프로젝트 것을 나중에 읽는다 — 이름이 같으면 **가까운
- * 쪽이 이긴다.** 스킬과 같은 규칙이다(skills/discover.js 의 dedupe).
+ * 이름이 같으면 **가까운 쪽이 이긴다.** 스킬과 같은 규칙이다(skills/discover.js 의 dedupe).
+ *
+ * ── 프로젝트 것을 **먼저** 읽는다 (2.0.0 8회차 사냥) ────────────────────
+ *
+ * 상한(최대)은 폴더별이 아니라 **모은 수의 누계**다. 그런데 이 PC 것을 먼저 읽고 있어서,
+ * 집에 정의가 상한만큼 있으면 프로젝트 폴더는 첫 파일에서 바로 끊겼다 — 「이 저장소에서는
+ * 이렇게 검토한다」 를 적어 둔 파일이 이 PC 사정 하나로 **하나도** 안 읽힌다. 게다가 바로
+ * 아래 줄이 「가까운 쪽이 이긴다」 를 약속하는데, 상한이 그 약속까지 거꾸로 뒤집었다.
+ *
+ * 상한을 폴더마다 따로 두는 길도 있었지만 안 골랐다. 이 목록은 **매 요청 Task 스키마에
+ * 통째로 실리는 글**이라(고를말), 폴더마다 두면 실리는 양이 두 배가 된다. 상한이 있는
+ * 까닭 자체가 그 양이라 그것을 늘리면 안 된다.
+ *
+ * 그래서 차례를 뒤집는다 — 자리가 모자랄 때 **먼저 자리를 갖는 쪽이 지금 이 저장소 것**
+ * 이어야 한다. 이 PC 것은 어느 저장소에서나 쓰는 것이고, 프로젝트 것은 여기서만 쓴다.
+ * 여기서 안 읽히면 그 정의는 쓸 자리가 아예 없어진다. 모으는 쪽은 그래서 「먼저 선 것이
+ * 이긴다」 로 바뀌었다(폴더하나).
+ *
+ * ── 프로젝트 것은 **믿는 폴더에서만** 읽는다 (2.0.0 4회차 사냥) ──────────
+ *
+ * 이 파일 머리말은 「스킬과 같은 갈래라 같은 규칙으로 읽는다」 고 적어 두었다. 그런데
+ * 스킬이 믿는 폴더에서만 읽히게 된 뒤로 이쪽은 그 문을 안 지났다. 정의의 **설명**은
+ * 매 요청 Task 스키마에 실리고(고를말), **지침**은 하위 모델의 일 앞에 붙는다 —
+ * 둘 다 모델에게 「이렇게 하라」 고 시키는 글이고, `.deel/agents` 는 저장소에 딸려
+ * 온다. clone 하고 켜기만 하면 남이 적은 지시문이 스키마에 실렸다.
+ *
+ * 부르는 자리(repl·oneshot·acp·doctor)는 넷인데 문은 여기 하나에 둔다. 넷에 따로
+ * 두면 언젠가 한 자리가 빠진다. 안 읽었으면 `안믿음` 으로 말한다 — 제가 적은 정의가
+ * 왜 안 보이는지 모르는 것이 두 번째로 나쁜 일이다(hooks.js 의 안믿음 과 같은 방식).
+ *
+ * 집에서 켰으면(`root` 가 집) 프로젝트 갈래를 건너뛴다. 같은 폴더를 두 번 읽어
+ * 출처가 「프로젝트」 로 바뀌고, 안 믿는 판에서는 이미 읽은 것을 안 읽었다고 말한다.
  */
-export function 에이전트읽기(root, { 집 = homedir(), env = process.env } = {}) {
+export function 에이전트읽기(root, { 집 = homedir(), env = process.env, 믿나: 믿나고르개 = null } = {}) {
   const 모은것 = new Map();
   const 버린것 = [];
   const 끔 = String(env.DEEL_AGENTS ?? '').trim().toLowerCase();
   if (끔 === 'off' || 끔 === '0' || 끔 === 'false') {
-    return { 에이전트들: [], 버린것: [], 켜짐: false };
+    return { 에이전트들: [], 버린것: [], 켜짐: false, 안믿음: false };
+  }
+  let 안믿음 = false;
+  if (고른경로(root) !== 고른경로(집)) {
+    const 믿는가 = 믿나고르개 ? 믿나고르개(root) : 믿나(root, { env });
+    if (믿는가) {
+      for (const 폴더 of 자리들(root)) 폴더하나(폴더, '프로젝트', 모은것, 버린것);
+    } else {
+      // 안 읽은 것이 **있을 때만** 말한다. 없는 것(ENOENT)은 조용히, 못 읽은 것은 안 읽은 것이다.
+      안믿음 = 자리들(root).some((폴더) => {
+        try { return readdirSync(폴더).some((n) => /\.(json|md)$/i.test(n)); } catch (e) { return e?.code !== 'ENOENT'; }
+      });
+    }
   }
   for (const 폴더 of 자리들(집)) 폴더하나(폴더, '이 PC', 모은것, 버린것);
-  for (const 폴더 of 자리들(root)) 폴더하나(폴더, '프로젝트', 모은것, 버린것);
-  return { 에이전트들: [...모은것.values()], 버린것, 켜짐: true };
+  return { 에이전트들: [...모은것.values()], 버린것, 켜짐: true, 안믿음 };
 }
 
 /** 이름으로 찾는다. 대소문자는 안 가린다 — 사람이 부르는 이름이다. */
@@ -194,6 +286,12 @@ export function 에이전트줄들(r) {
   const 줄 = [];
   if (!r.켜짐) { 줄.push({ 상태: 'warn', 이름: '에이전트', 값: '꺼져 있습니다 (DEEL_AGENTS=off)' }); return 줄; }
   for (const 왜 of r.버린것 ?? []) 줄.push({ 상태: 'warn', 이름: '에이전트 · 못 읽음', 값: 왜 });
+  if (r.안믿음) {
+    줄.push({
+      상태: 'warn', 이름: '에이전트 · 프로젝트', 값: '.deel/agents · .claude/agents',
+      덧말: '믿는 폴더가 아니라서 안 읽습니다 — 읽게 하려면 deel trust',
+    });
+  }
   if (!r.에이전트들.length) return 줄;
   줄.push({
     상태: 'ok', 이름: '에이전트', 값: `${r.에이전트들.length}개`,

package/src/agent/askcheck.js

@@ -66,12 +66,17 @@ export function 얼마나들었나(작은것, 큰것) {
  *
  * 번호(1. 2)·글머리(- ·)·동그라미 숫자를 센다. 줄머리에 있는 것만 센다 —
  * 글 가운데 있는 "1.6.1" 같은 것을 항목으로 세면 안 된다.
+ *
+ * `\p{Mn}?` 는 ▪️ 같은 이모지 꼴 가림표(U+FE0F)다. 표에는 ▪️ 를 넣어 두었는데
+ * 가림표가 글머리와 빈칸 사이에 끼어 그 줄머리가 한 번도 안 맞았다 — 사용자가
+ * ▪️ 로 낱낱이 적어 줘도 「적어 준 것이 0개」 라, 그 목록을 그대로 되읽는 물음이
+ * 지나갔다. asks.js 의 줄머리는 6회차(AS3)에 고쳤는데 여기만 남아 있었다.
  */
 export function 항목수(요청) {
   const 줄들 = String(요청 ?? '').split('\n');
   let 몇 = 0;
   for (const 줄 of 줄들) {
-    if (/^\s*(\d{1,2}\s*[.)]|[-*·▪️•]|[①-⑮])\s+\S/.test(줄)) 몇 += 1;
+    if (/^\s*(\d{1,2}\s*[.)]|[-*·▪️•]|[①-⑮])\p{Mn}?\s+\S/u.test(줄)) 몇 += 1;
   }
   return 몇;
 }
@@ -121,7 +126,10 @@ const 고르라는물음 = /어(느|떤)\s*(것|거|쪽|부분|순서)|무엇(
  *
  * '어느 쪽으로 할까요' 는 여기 안 넣는다. 그건 진짜 갈림길일 때가 많다.
  */
-const 무슨일할까 = /(어떤|무슨)\s*(작업|일)(을|를)?\s*(진행|할|하)|무엇을\s*(할|진행|해\s*드릴)|뭘\s*(할|해\s*드릴)|어떤\s*것부터|무엇부터|뭐부터|what\s+(should|would)\s+(i|we)\s+(do|work\s+on)|how\s+(should|would)\s+(i|we)\s+proceed/i;
+// 사람의 말이 갈림길을 묻는 꼴인가 — 물음표로 끝나거나 「쓸까·할까」 「or·vs·아니면」.
+const 갈림길물음 = /[?？]\s*$|(?:할까|쓸까|좋을까|나을까|갈까|둘까)|\b(?:or|vs\.?|versus)\b|아니면/i;
+
+const 무슨일할까 =/(어떤|무슨)\s*(작업|일)(을|를)?\s*(진행|할|하)|무엇을\s*(할|진행|해\s*드릴)|뭘\s*(할|해\s*드릴)|어떤\s*것부터|무엇부터|뭐부터|what\s+(should|would)\s+(i|we)\s+(do|work\s+on)|how\s+(should|would)\s+(i|we)\s+proceed/i;
 
 /*
  * 이만큼 겹치면 "이미 물어본 것" 으로 본다.
@@ -199,6 +207,24 @@ export function 물음검사({ 물음 = '', 고를것 = [], 이해 = '', 요청
   // 선택지 하나하나가 사용자 말 안에 이미 들어 있으면, 그건 갈림길이 아니라
   // 목록을 되읽어 준 것이다. 둘 이상이면 그렇게 본다 — 하나는 우연일 수 있다.
   const 이미있는것 = 것들.filter((x) => 얼마나들었나(x, 요청) >= 같은것문턱);
+  /*
+   * 단, 사람이 그 둘을 **갈림길로 물었으면** 할 일 목록이 아니다.
+   *
+   * 「PostgreSQL 쓸까 SQLite 쓸까?」 에 모델이 그 둘을 선택지로 되물었더니 「할 일
+   * 목록이니 **전부** 하세요」 가 돌아갔다 — 둘 다 쓸 수는 없다. 되묻는 것을 막는
+   * 것은 같다. 돌려주는 말만 다르다: 사람은 권해 달라고 물은 것이다.
+   * 고치라는 말이 들었거나(「둘 다 고쳐줄래?」) 줄머리 목록이면 여전히 할 일 목록이다.
+   * (6회차 Gemini 되묻기6 Q2)
+   */
+  if (이미있는것.length >= 2 && 항목수(요청) < 2 && !손대라했나(요청) && 갈림길물음.test(요청)) {
+    return {
+      ok: false,
+      왜: `사람이 물은 갈림길(${이미있는것.slice(0, 3).join(' · ')})을 그대로 되물음`,
+      할말: '사람은 이 가운데 무엇이 나은지 **물었습니다**. 같은 물음을 돌려주지 마세요.'
+        + ' 지금 아는 것(코드·설정·쓰임새)으로 견줘서 하나를 권하고, 까닭을 한두 줄 적으세요.'
+        + ' 사람만 아는 것 하나가 갈림길을 가르면(예: 어디에 배포하나) 그 한 가지만 콕 집어 물으세요.',
+    };
+  }
   if (이미있는것.length >= 2) {
     return {
       ok: false,
@@ -240,9 +266,21 @@ export function 물음검사({ 물음 = '', 고를것 = [], 이해 = '', 요청
   // 사람 눈에는 앞의 대답이 통째로 무시된 것으로 보인다 — 실제로도 그렇다.
   const 앞것 = (Array.isArray(이미물은것) ? 이미물은것 : []);
   for (const 앞 of 앞것) {
-    const 앞물음 = String(앞?.물음 ?? 앞 ?? '');
+    // 글자로 적힌 앞것도 받는다. 다만 **객체인데 물음이 없으면** 건너뛴다 —
+    // `앞?.물음 ?? 앞` 으로 받았더니 그 객체가 "[object Object]" 로 굳어,
+    // 엉뚱한 물음이 그 글자와 겹쳐 막히고 막는 말에도 그대로 실려 나갔다.
+    const 앞물음 = typeof 앞 === 'string' ? 앞 : String(앞?.물음 ?? '');
     if (!앞물음) continue;
-    if (얼마나들었나(물, 앞물음) < 또물음문턱) continue;
+    /*
+     * 새 물음이 앞물음 안에 얼마나 드나만 재면, 앞에 서두를 붙인 같은 물음이 지나간다 —
+     * 「답변을 확인하지 못해 다시 여쭙는데 어떤 작업을 진행할까요?」 가 0.38 이었다.
+     * 「무슨 일을 할까요」 꼴끼리는 거꾸로(앞물음이 새 물음 안에 드나)도 본다. 이 꼴에만
+     * 거는 것은, 「어느 것으로 할까요?」 같은 짧은 물음은 **좁힌** 새 물음 안에도 통째로
+     * 들기 때문이다 — 그건 또 묻는 것이 아니다. (6회차 Gemini 되묻기6 Q3)
+     */
+    const 겹침 = Math.max(얼마나들었나(물, 앞물음),
+      무슨일할까.test(앞물음) && 무슨일할까.test(물) ? 얼마나들었나(앞물음, 물) : 0);
+    if (겹침 < 또물음문턱) continue;
     const 답 = String(앞?.답 ?? '').trim();
     return {
       ok: false,
@@ -266,8 +304,14 @@ export function 물음검사({ 물음 = '', 고를것 = [], 이해 = '', 요청
   }
 
   // ── 5. 한 번에 하나만 ────────────────────────────────────────────────
-  const 물음표 = (물.match(/[?？]/g) ?? []).length;
-  if (물음표 >= 2) {
+  // 코드 울타리·코드 조각·주소 속 물음표는 물음이 아니다 — 「`user?.name ? …` 로 수정할까요?」
+  // 는 물음 하나인데 셋으로 셌다 (6회차 Gemini 되묻기6 Q1).
+  const 물음글 = 물.replace(/```[\s\S]*?(?:```|$)/g, ' ').replace(/`[^`\n]*`/g, ' ').replace(/\b[a-z][a-z0-9+.-]*:\/\/\S+/gi, ' ');
+  const 물음표 = (물음글.match(/[?？]/g) ?? []).length;
+  // 잇따라 찍은 물음표(「할까요??」)는 강조지 물음이 아니다 — 겹쳐 찍은 만큼 도로 뺀다.
+  // 안 빼면 물음 하나가 둘로 세어져 「한 번에 여럿을 물음」 으로 막힌다.
+  const 겹쳐찍은것 = (물음글.match(/[?？]{2,}/g) ?? []).reduce((합, 무리) => 합 + 무리.length - 1, 0);
+  if (물음표 - 겹쳐찍은것 >= 2) {
     return {
       ok: false,
       왜: '한 번에 여럿을 물음',

package/src/agent/asks.js

@@ -75,7 +75,27 @@ function 낱말이닿았나(낱말, 덩어리) {
    *
    * 영문은 안 줄인다. cli·deel·npm 처럼 원래 짧아서, 줄이면 아무 데나 걸린다.
    */
-  if (!/^[가-힣]/.test(낱말)) return false;
+  if (!/^[가-힣]/.test(낱말)) {
+    /*
+     * 영문·숫자 머리에 한글 조사가 붙은 낱말(`readme를` · `api를` · `3번을`)은 **꼬리만** 뗀다
+     * (6회차 시킨것6au-a AS2). 낱말을 가르는 자리가 영문과 한글 사이를 안 끊어서 조사가 붙은
+     * 채로 남았고, 위의 줄이기는 한글로 시작할 때만 해서 README.md 를 고치고 「README 고쳤습니다」
+     * 라고 보고해도 안 닿았다 — 다 한 일을 안 했다고 되밀었다. 영문 머리 자체는 여전히 안 줄인다.
+     */
+    const 머리 = /^[0-9a-z]+(?=[가-힣]+$)/.exec(낱말)?.[0];
+    if (!머리) return false;
+    /*
+     * 머리가 **한 글자**면(`7을` · `3을`) 아래 고리가 한 번도 안 돈다 — 문턱이 두
+     * 글자여서 시작값이 이미 문턱 밑이다. 「이슈 7을 닫아줘」 를 닫고 「이슈 7
+     * 닫았습니다」 라고 적어도 안 닿아, 한 일을 안 했다고 되밀었다. 여기서 머리까지
+     * 내려가 본다 — 꼬리만 떼자고 한 자리이니 머리는 그대로 남는다.
+     */
+    if (머리.length < 2 && 덩어리.includes(머리)) return true;
+    for (let n = 낱말.length - 1; n >= Math.max(머리.length, 2); n--) {
+      if (덩어리.includes(낱말.slice(0, n))) return true;
+    }
+    return false;
+  }
   for (let n = 낱말.length - 1; n >= 2; n--) {
     if (덩어리.includes(낱말.slice(0, n))) return true;
   }
@@ -91,7 +111,9 @@ function 낱말이닿았나(낱말, 덩어리) {
 const 시킴꼴 = /(줘|주세요|주라|해라|하라|하자|해다오|할래|해야\s*(해|돼|한다)|바랍니다|부탁(해|합니다|드립니다))[\s.!~]*$/;
 
 // 줄머리 표. 번호(1. 2))·글머리(- * ·)·동그라미 숫자.
-const 줄머리 = /^\s*(?:(\d{1,2})\s*[.)]|[-*·▪️•]|[①-⑮])\s+/;
+const 줄머리 = /^\s*(?:(\d{1,2})\s*[.)]|[-*·▪️•]|[①-⑮])\p{Mn}?\s+/u;
+// 끝의 \p{Mn}? 는 ▪️ 같은 이모지 꼴 가림표(U+FE0F)다. 표에는 ▪️ 를 넣어 두었는데 가림표가
+// 빈칸 앞에 끼어 그 줄머리가 한 번도 안 맞았다 (6회차 시킨것6au-a AS3).
 
 /*
  * ── 시킨 것이 아니라 **조건**인 줄 ─────────────────────────────────────
@@ -135,15 +157,47 @@ const 맨동사 = new Set([
 ]);
 // 「…하지 마」 는 무슨 일이 있어도 할 일이 아니다. 안 하는 것이 다 한 것이다.
 const 하지마 = /(?:하지|치지|시키지|되지|넣지|쓰지|고치지|바꾸지|건드리지|만지지)\s*(?:는)?\s*(?:마|말)/;
-const 하지마En = /\b(?:do not|don'?t|never|without)\b/i;
+// `without` 은 여기 없다. 그건 금지가 아니라 **단서**다 — 「Deploy the app without
+// downtime」 은 하라는 말인데 줄째로 조건이 되어 빠졌고, 남은 항목이 하나뿐이면
+// 대조가 통째로 안 돈다(요청항목들 은 둘부터 센다).
+const 하지마En = /\b(?:do not|don'?t|never)\b/i;
+
+/*
+ * 줄 **끝**이 「…지 마」 꼴이면 그 줄은 통째로 금지다 (6회차 시킨것6au-b AS6).
+ *
+ * 위 동사 목록은 줄 가운데 「고치지 말고 …」 를 잡는 자리라 동사를 골라 두었다 —
+ * 「잊지 말고 테스트 돌려줘」 는 금지가 아니라 할 일이다. 그런데 그 목록 밖의 「손대지 마」 ·
+ * 「건들지 마세요」 · 「지우지 말 것」 이 할 일로 잡혀, 지킨 금지를 「지금 하세요」 로 되밀었다.
+ * 줄 끝에 오면 뒤에 이어지는 할 일이 없으니 동사를 가릴 까닭이 없다.
+ */
+const 줄끝금지 = /지\s*(?:마|마세요|마라|말\s*것|말아\s*(?:줘|주세요|라)?)[\s.!~]*$/;
+
+/** 조건에만 쓰이는 말인가 — 수·한계말·맨 동사. 이것뿐이면 그 줄은 할 일이 아니다. */
+const 조건말인가 = (w) => 한계말.has(w) || 맨동사.has(w) || /^\d/.test(w);
 
 /** 이 줄이 할 일이 아니라 그 일에 붙은 조건인가. */
 export function 조건줄인가(글) {
   const s = String(글 ?? '');
-  if (하지마.test(s) || 하지마En.test(s)) return true;
+  /*
+   * 줄 **가운데** 금지는 그 앞까지만 금지다. 뒤에 붙은 것은 할 일이다 —
+   * 「기존 스타일은 고치지 말고 새 테마 파일을 만들어줘」 를 통째로 금지로 보면
+   * 「만들어줘」 가 사라지고, 그 줄이 빠지면서 항목이 둘 미만이 되면 대조가
+   * 통째로 안 돈다(요청항목들 은 둘부터 센다).
+   *
+   * 그래서 금지 뒤에 **남는 말**로 가른다. 남는 것이 조건말뿐이거나 아예 없으면
+   * (「기존 코드는 고치지 말고.」 · 「아무것도 건드리지 말고 그냥 둬」) 줄 전체가 금지다.
+   *
+   * 줄 끝이 금지인 줄은 아예 안 본다. 「코드는 건드리지 마세요」 의 남는 말은 '세요'
+   * 인데, 그걸 뒤에 붙은 할 일로 읽으면 지킨 금지가 할 일로 되살아난다.
+   */
+  if (!줄끝금지.test(s)) {
+    const 금지 = 하지마.exec(s);
+    if (금지 && 알맹이낱말(s.slice(금지.index + 금지[0].length)).some((w) => !조건말인가(w))) return false;
+  }
+  if (하지마.test(s) || 하지마En.test(s) || 줄끝금지.test(s)) return true;
   const 낱말 = 알맹이낱말(s);
   if (!낱말.length) return false;   // 잴 것이 없으면 안 건다 — 빠진것 이 따로 거른다
-  return 낱말.every((w) => 한계말.has(w) || 맨동사.has(w) || /^\d/.test(w));
+  return 낱말.every(조건말인가);
 }
 
 /**

package/src/agent/budget.js

@@ -141,9 +141,16 @@ export function 한번에낼글자수(ctx) {
  * 아니다. 부모만큼 주면 하위가 부모 일을 통째로 다시 하려 들고, 그러면
  * 창을 나눈 뜻이 없어진다. 대신 너무 적으면 맡긴 덩이도 못 끝내니
  * 8걸음은 무슨 일이 있어도 준다.
+ *
+ * 부모 모드를 알면 하위 모드와 부모 모드 가운데 걸음이 적은 쪽의 절반이다.
+ * 하위 모드만 보면, 걸음이 두 배인 모드(orchestrator)를 하위로 고른 순간
+ * 그 절반이 곧 부모 몫이 되어 「부모보다 적게」 가 깨졌다 — code 부모가
+ * orchestrator 하위를 띄우면 16k 에서 24 대 24. 모드를 부모보다 세게 못
+ * 올리는 것(tools/task.js 하위모드)과 같은 뜻을 걸음 수에도 건다.
  */
-export function 하위걸음수(모드id, ctx) {
-  return Math.max(8, Math.round(걸음수(모드id, ctx) / 2));
+export function 하위걸음수(모드id, ctx, 부모모드id = null) {
+  const 바탕 = 부모모드id == null ? 걸음수(모드id, ctx) : Math.min(걸음수(모드id, ctx), 걸음수(부모모드id, ctx));
+  return Math.max(8, Math.round(바탕 / 2));
 }
 
 /**

package/src/agent/card.js

@@ -28,7 +28,8 @@
 //
 // 조금 겪고 함부로 바꾸지 않는다. 걸음이 얼마 안 될 때 우연히 한 번 잘린 것으로
 // 하네스를 조이면, 멀쩡한 모델을 붙들어 매는 셈이 된다 — 안 배우느니만 못하다.
-// 그래서 걸음 상한과 비율 문턱을 둘 다 넘어야 움직인다.
+// 그래서 걸음 하한(최소걸음)과 비율 문턱을 둘 다 넘어야 움직인다. 많이 겪을수록
+// 더 잘 맞추는 쪽이지, 많이 겪으면 멈추는 쪽이 아니다.
 
 import { 내장카드, 추론형왜 } from './preset.js';
 
@@ -122,7 +123,12 @@ export function 카드(모델, 본것 = null, 겪은것 = null) {
     내장,
     // 판단을 아직 못 하는 상태인지 화면이 알아야 한다 — '바꾼 것 없음' 과
     // '아직 모름' 은 다른 말이다.
-    아직모름: 걸음 < 최소걸음,
+    //
+    // **이미 바꾼 것이 있으면 미루고 있는 것이 아니다.** 내장 카드(preset.js)는
+    // 걸음 관문 앞에 서서 한 걸음도 안 걸은 모델의 하네스를 이미 바꾼다. 그런데
+    // /card 화면은 아직모름 이면 왜 를 통째로 감추고 「아직 판단하지 않습니다」
+    // 만 찍는다(commands/work.js) — 바꿔 놓고 안 바꿨다고 말하는 화면이 된다.
+    아직모름: 걸음 < 최소걸음 && 왜.length === 0,
   };
 }