@angar2/taskery 0.5.0 → 0.6.1

package/README.md

@@ -16,6 +16,9 @@ AI 코딩 에이전트의 자율 개발을 위한 Task 기반의 가드레일
 | 에이전트가 catastrophic 사고를 일으킬 수 있음 | 필수 hook으로 차단 — 정상 흐름에는 무간섭 |
 | 에이전트가 작성한 코드의 자가검증으로 인해 문제를 놓침 (confirmation bias) | 테스트 시 별도 격리 세션 호출(`/task-test`) — 메인 세션의 가정 없이 독립 검증 |
 | 단일 메인 세션 운영으로 인해 task를 직렬로 진행해야 하는 병목 | 같은 프로젝트에서 여러 메인 세션이 독립 작업 폴더(worktree)로 병렬 진행 — 머지 시점에 직렬화로 정합성 유지 |
+| 검수 중 한 줄만 고쳐도 전체 테스트를 다시 돌려 대기 시간이 길어짐 | 수정 구간에는 변경이 닿는 테스트만 실행 — 전체 실행은 task당 1회로 제한 |
+| 테스트가 앱 화면을 띄우고 조작해 그동안 컴퓨터를 쓸 수 없음 | 화면·입력을 점유하는 테스트는 창을 띄우지 않는 실행 경로가 준비된 경우에만 자동 실행 — 없으면 사용자 승인 후 실행 |
+| 프로젝트마다 개발·테스트 방식이 다른데 공통 규칙만 적용됨 | 프로젝트 전용 규칙 파일(`*.local.md`)을 각 스킬이 읽어 우선 적용 — 패키지를 갱신해도 덮어쓰지 않음 |
 
 > catastrophic 사고 예시 — git 운영 정책 위반, 검증 우회, 완료된 task 문서 재수정 등
 
@@ -39,7 +42,7 @@ draft → planned → developing → developed → testing → tested → closed
 | `developed` | 구현 완료 (자가 검증 통과) |
 | `testing` | 독립 검증 진행 중 |
 | `tested` | 독립 검증 완료 |
-| `closed` | git 커밋 + dev 병합 완료 |
+| `closed` | git 커밋 + 부모 브랜치 병합 완료 |
 
 > 상태별 전이 조건과 task 문서 양식은 [TASK-DOC.md](https://github.com/angar2/taskery/blob/main/plan/TASK-DOC.md)에서 확인 가능
 
@@ -125,6 +128,8 @@ my-app/
     │   ├─ GIT_RULE.md                    # 로컬 깃 운영 규칙
     │   ├─ CHANGELOG_RULE.md              # CHANGELOG 작성 규칙
     │   ├─ MOCKUP_RULE.md                 # UX/UI HTML 목업 규칙
+    │   ├─ DEV_RULE.local.md              # (선택) 이 프로젝트의 구현·테스트 실행 방식
+    │   ├─ TEST_RULE.local.md             # (선택) 이 프로젝트의 검증 범위·방식
     │   └─ *.local.md                     # 사용자 오버라이드 규칙 (패키지 업데이트 대상 제외)
     ├─ plans/                             # plan(기능 그룹)별 PLAN.md / ROADMAP.md (<NNN_slug>/)
     ├─ tasks/                             # task 문서 (<NNN_slug>/BACKLOG.md / spec-diffs / screenshots / mockup 포함)
@@ -153,8 +158,8 @@ my-app/
 같은 프로젝트에서 여러 메인 세션을 동시에 운영해 독립 task를 병렬로 진행한다.
 
 - 새 task를 시작하면(`/task-init`) 작업 폴더(`~/.taskery/worktrees/<projectId>/TASK-NNN_<출처>_<슬러그>/`)와 작업 브랜치를 함께 분기한다.
-- 작업 폴더에서 새 메인 세션을 열어 진행하거나, 메인 세션 1개로 모든 작업을 지휘하거나, 메인이 서브 세션을 호출해 병렬로 진행한다 — 운영 방식은 자유. 메인 워크트리(원본 폴더)는 `dev` 전용 상태로 유지된다.
-- task 완료(`/task-close`) 시 머지 락으로 직렬화한 후 dev에 `--no-ff` 병합한다. 다른 세션이 먼저 머지해 충돌이 발생하면 본 세션이 단순/의미적/판단 불가 3단계로 해결을 시도한다.
+- 작업 폴더에서 새 메인 세션을 열어 진행하거나, 메인 세션 1개로 모든 작업을 지휘하거나, 메인이 서브 세션을 호출해 병렬로 진행한다 — 운영 방식은 자유. 메인 워크트리(원본 폴더)는 task를 시작한 브랜치(*부모 브랜치*, 기본은 `dev`)를 그대로 유지한다.
+- task 완료(`/task-close`) 시 머지 락으로 직렬화한 후 **그 부모 브랜치**에 `--no-ff` 병합한다(개인은 `dev`, 회사/로드맵은 서 있던 브랜치). 다른 세션이 먼저 머지해 충돌이 발생하면 본 세션이 단순/의미적/판단 불가 3단계로 해결을 시도한다.
 - 머지 직후 작업 폴더와 작업 브랜치는 자동 정리된다(보존 키워드 사용 시 양쪽 유지). 안전망으로 복구 명령이 함께 출력된다.
 
 요건: git ≥ 2.31. 보조 명령 `npx @angar2/taskery status` / `prune`로 진행 현황과 stale 정리를 확인한다.
@@ -189,7 +194,7 @@ my-app/
 | `/task-plan` | task | task의 요구사항·범위·개발 계획·테스트 계획 작성 |
 | `/task-dev` | task | 계획에 따른 단계별 구현 + 자가 검증 |
 | `/task-test` | task | 별도 격리 세션에서 독립 검증 (메인 가정 차단) |
-| `/task-close` | task | 최종 검증 후 git 커밋 + dev 브랜치 `--no-ff` 병합 |
+| `/task-close` | task | 최종 검증 후 git 커밋 + 부모 브랜치 `--no-ff` 병합 |
 | `/add-backlog` | meta | 사용자 발화로 plan(기능 그룹)별 `tasks/<NNN_slug>/BACKLOG.md`에 task 후보 1건씩 추가 (0.1.2+) |
 | `/log-friction` | meta | 사용자 불편을 `.project/FRICTION_LOG.md`에 한 행 기록 |
 | `/run-team` | meta | 여러 작업을 묶을 수 있는 단위로 task로 나눠 자동 병렬 처리 — 리더 세션이 팀원(독립 세션)에게 task를 1건씩 분배하고 흐름을 관리 (Claude 전용 · 실험 기능 전제 · 0.3.x+) |
@@ -240,7 +245,7 @@ npx @angar2/taskery init
 /task-plan TASK-001            # draft → planned : 요구사항·범위·개발 계획·테스트 계획 작성
 /task-dev TASK-001             # planned → developed : 단계별 구현과 자체 검증
 /task-test TASK-001            # developed → tested : 별도 격리 세션으로 독립 검증
-/task-close TASK-001           # tested → closed : 최종 검증 후 git 커밋과 dev 병합
+/task-close TASK-001           # tested → closed : 최종 검증 후 git 커밋과 부모 브랜치 병합
 
 # 불편 발생 시 등록
 /log-friction                  # 사용자 불편 한 행 기록
@@ -258,6 +263,7 @@ npx @angar2/taskery init
 - 사용자가 재구현을 요청하면 → `testing` → `developing`으로 회귀해 `/task-dev`가 자동 발동된다.
 - 사용자가 결함을 인지한 채 종결을 지시하면 → `testing` → `tested`로 진행하고 결함을 명시한 후 `/task-close`로 이행된다.
 - UNCERTAIN(자동 검증이 불가능한 시나리오)은 사용자가 직접 검수한 결과를 답하면 메인 세션이 PASS/FAIL로 해석해 위 두 흐름 중 하나로 합류시킨다.
+- 검증에 필요한 테스트가 화면·입력을 점유해 실행을 보류한 경우에는, 지금 실행할지 / 자리를 비울 때로 미룰지 / 창을 띄우지 않는 실행 경로를 마련할지를 사용자가 고른다. 승인 없이 임의로 실행하지 않는다.
 
 ---
 

package/bin/close.js

@@ -5,10 +5,10 @@
  * `npx @angar2/taskery close <TASK-NNN>` — close 결정적 준비.
  *
  * 게이트(status=tested) → Phase 커밋(D2 자동 매핑) → status=closed → flows/문서 커밋 → 추적마커까지
- * 코드가 수행하고 멈춘다. 이후 비가역(사전 rebase+충돌해결 / 머지 락 / dev --no-ff 머지 /
+ * 코드가 수행하고 멈춘다. 이후 비가역(사전 rebase+충돌해결 / 머지 락 / 부모 --no-ff 머지 /
  * worktree remove / branch -d)은 스킬(task-close)이 git-guard hook + 복구출력 보호 하에 수행.
  *
- * stdout: { prepped, branch, wtPath, registered, commits, aheadOfDev }. exit 0.
+ * stdout: { prepped, branch, parent, wtPath, registered, commits, aheadOfParent }. parent = 머지 대상. exit 0.
  * 콜백(스킬이 LLM 판단 후 처리):
  *   - exit 3 + { blocked:'status', current }  — status가 tested 아님 (게이트 차단)
  *   - exit 2 + { blocked:'mapping', files, phases, reason } — Phase↔파일 매핑 모호 (수동 커밋 필요)

package/bin/fork.js

@@ -57,8 +57,10 @@ async function main() {
     console.error(`type은 ${VALID_TYPES.join(' | ')} 중 하나 (받음: ${type})`);
     process.exit(1);
   }
-  if (!/^(BL-\d+|RM-\d+|DR)$/.test(src)) {
-    console.error(`src는 BL-NNN | RM-NNN | DR 형식 (받음: ${src})`);
+  // ST-N = 로드맵 Stage 출처 (ROADMAP은 Stage 단위·RM 채번 없음 — recordion FRICTION 2026-08-03 반영).
+  // RM-NNN은 구형 호환으로 계속 수용.
+  if (!/^(BL-\d+|RM-\d+|ST-\d+|DR)$/.test(src)) {
+    console.error(`src는 BL-NNN | ST-N(로드맵 Stage) | DR 형식 (받음: ${src}. 구형 RM-NNN도 호환)`);
     process.exit(1);
   }
   if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug)) {
@@ -96,6 +98,7 @@ async function main() {
         title: opts.title,
         type,
         size: opts.size,
+        parent: result.parent,
         promoted: !!opts.promote,
       });
       out = { ...result, docPath: doc.file, registered: doc.registered, promoted: doc.promoted };

package/bin/lib.js

@@ -22,11 +22,11 @@
  *   - getInitLockPath(projectId): ~/.taskery/<projectId>.init.lock (task 분기 직렬화용)
  *   - withMergeLock(projectId, fn, opts): proper-lockfile로 머지 락 + fn 실행 + 자동 release
  *   - withMetaLock(filePath, fn, opts): 메타 파일 쓰기 락 + fn 실행
- *   - getActiveTasks(mainWtPath): SSoT 조회 (git branch --no-merged dev --list 'feature/*_TASK-*' ...)
- *   - getNextTaskNumber(mainWtPath): (진행중 ∪ dev 머지 히스토리) 최대 + 1
- *   - forkTask(mainWtPath, {type,dev,src,slug}): init 락 안에서 채번+워크트리·브랜치 생성 원자 실행
- *   - assertMainWorktreeOnDev(mainWtPath): 메인 워크트리가 dev 체크아웃 상태인지 검증
- *   - assertDevExists(mainWtPath): dev 브랜치 존재 검증
+ *   - getActiveTasks(mainWtPath): SSoT 조회 (git branch --list 'feature/*_TASK-*' ...)
+ *   - getNextTaskNumber(mainWtPath): (진행중 ∪ 전 ref 머지 히스토리) 최대 + 1 (부모 무관 전역 채번)
+ *   - forkTask(mainWtPath, {type,dev,src,slug}): init 락 안에서 부모(현재 브랜치) 캡처+채번+워크트리·브랜치 생성 원자 실행
+ *   - currentBranch(mainWtPath): 메인 워크트리 현재 브랜치 = 부모 브랜치(detached면 'HEAD')
+ *   - assertMainWorktreeOn(mainWtPath, branch): 메인 워크트리가 지정 브랜치 체크아웃 상태인지 검증
  *
  * 백로그 (0.1.2+):
  *   - getActiveVersion(mainWtPath): .project/AGENT-GUIDE.md에서 활성 plan 식별자(버전 또는 기능 그룹명) 추출
@@ -247,7 +247,7 @@ function getWorktreesRoot(projectId) {
 }
 
 function getWorktreePath(projectId, { taskNum, src, slug }) {
-  // src = 'BL-NNN' | 'RM-NNN' | 'DR'
+  // src = 'BL-NNN' | 'ST-N'(로드맵 Stage) | 'DR' (구형 'RM-NNN' 호환)
   const nnn = String(taskNum).padStart(3, '0');
   return path.join(getWorktreesRoot(projectId), `TASK-${nnn}_${src}_${slug}`);
 }
@@ -308,17 +308,15 @@ async function withMetaLock(filePath, fn, opts = {}) {
   }
 }
 
-function assertDevExists(mainWtPath) {
-  const ok = gitCapture(mainWtPath, ['rev-parse', '--verify', 'dev'], { allowFail: true });
-  if (ok === null) {
-    throw new Error('dev 브랜치 부재. 사용자 결정 필요 (생성?).');
-  }
+function currentBranch(mainWtPath) {
+  // 메인 워크트리의 현재 브랜치 = 태스크의 부모 브랜치(0.6.0). detached HEAD면 'HEAD' 반환.
+  return gitCapture(mainWtPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
 }
 
-function assertMainWorktreeOnDev(mainWtPath) {
-  const current = gitCapture(mainWtPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
-  if (current !== 'dev') {
-    throw new Error(`메인 워크트리가 dev 아님 (현재: ${current}). taskery 정책 위배.`);
+function assertMainWorktreeOn(mainWtPath, branch) {
+  const current = currentBranch(mainWtPath);
+  if (current !== branch) {
+    throw new Error(`메인 워크트리가 ${branch} 아님 (현재: ${current}). 부모 브랜치로 체크아웃 필요.`);
   }
 }
 
@@ -341,8 +339,8 @@ function parseBranchName(branch) {
 }
 
 function getActiveTasks(mainWtPath) {
-  // SSoT — TASK-* 패턴 작업 브랜치 (분기 직후 빈 브랜치 포함). `--no-merged dev` 미사용:
-  // 워크트리 분기 직후 브랜치는 dev와 동일 commit이라 `--no-merged dev`가 *완전 머지 상태*로
+  // SSoT — TASK-* 패턴 작업 브랜치 (분기 직후 빈 브랜치 포함). `--no-merged <부모>` 미사용:
+  // 워크트리 분기 직후 브랜치는 부모와 동일 commit이라 `--no-merged`가 *완전 머지 상태*로
   // 처리 → 빈 결과 → getNextTaskNumber 충돌. 브랜치 존재 자체가 SSoT (정상 흐름은 task-close
   // 자동 삭제로 자연 정리, 보존 키워드 잔존분도 *진행중*으로 잡힘이 정합).
   const out = gitCapture(mainWtPath, ['branch', '--list', ...BRANCH_PATTERNS]);
@@ -358,12 +356,14 @@ function getActiveTasks(mainWtPath) {
 function getNextTaskNumber(mainWtPath) {
   // 1. 진행중 (SSoT)
   const activeNums = getActiveTasks(mainWtPath).map((t) => t.taskNum);
-  // 2. dev 머지 히스토리 (GIT_RULE 풍부 메시지)
-  //    --extended-regexp(ERE)에서 `+`는 수량자 — `\+`로 쓰면 *리터럴 +* 가 되어 "TASK-001"을
-  //    못 잡는다. 그러면 close로 활성 브랜치가 사라진 뒤 채번이 1로 리셋돼 순차 작업이 번호 충돌.
+  // 2. 머지 히스토리 (GIT_RULE 풍부 메시지) — 모든 ref(`--all`) 스캔.
+  //    부모 브랜치가 dev로 고정되지 않으므로(0.6.0) 닫힌 태스크는 각자의 부모에 병합돼 있다.
+  //    특정 부모(과거 'dev') 하나만 grep하면 다른 부모로 닫힌 번호를 놓쳐 채번 충돌 → `--all`로
+  //    전 ref의 TASK-NNN 최대를 취해 번호를 리포 전역으로 유지.
+  //    --extended-regexp(ERE)에서 `+`는 수량자 — `\+`는 *리터럴 +* 라 "TASK-001"을 못 잡는다.
   const log = gitCapture(mainWtPath, [
     'log',
-    'dev',
+    '--all',
     '--grep',
     'TASK-[0-9]+',
     '--extended-regexp',
@@ -383,10 +383,14 @@ async function forkTask(mainWtPath, { type, dev, src, slug }) {
   // getNextTaskNumber 직후 worktree add까지 끝내므로 다음 호출은 늘어난 번호를 본다.
   const projectId = getProjectId(mainWtPath);
   return withMetaLock(getInitLockPath(projectId), () => {
-    assertDevExists(mainWtPath);
-    assertMainWorktreeOnDev(mainWtPath);
-    // SSoT 안전망 — 같은 출처(BL-NNN/RM-NNN)가 이미 진행중이면 거부. DR은 별도 ID 없어 검사 제외.
-    if (src !== 'DR') {
+    // 부모 = 메인 워크트리의 현재 브랜치(0.6.0). dev 하드코딩 제거 — 서 있는 브랜치가 곧 부모.
+    const parent = currentBranch(mainWtPath);
+    if (parent === 'HEAD') {
+      throw new Error('메인 워크트리가 detached HEAD — 부모로 삼을 브랜치에 체크아웃 필요.');
+    }
+    // SSoT 안전망 — 같은 항목 출처(BL-NNN/구형 RM-NNN)가 이미 진행중이면 거부.
+    // DR(별도 ID 없음)·ST-N(Stage 하나에서 복수 task가 정상)은 검사 제외.
+    if (/^(BL|RM)-/.test(src)) {
       const dup = getActiveTasks(mainWtPath).find((t) => t.src === src);
       if (dup) {
         throw new Error(`${src} 이미 진행중 (${dup.branch}) — 다른 세션이 같은 항목 진행`);
@@ -397,11 +401,12 @@ async function forkTask(mainWtPath, { type, dev, src, slug }) {
     const branch = `${type}/${dev}_TASK-${nnn}_${src}_${slug}`;
     const wtPath = getWorktreePath(projectId, { taskNum, src, slug });
     mkdirp(getWorktreesRoot(projectId));
-    // 동일 브랜치명은 git이 거부(같은 항목 동시 분기 차단). 실패 시 throw → fork.js가 사용자 보고.
-    execFileSync('git', ['-C', mainWtPath, 'worktree', 'add', wtPath, '-b', branch, 'dev'], {
+    // 부모 브랜치를 base로 워크트리·브랜치 생성. 동일 브랜치명은 git이 거부(같은 항목 동시 분기
+    // 차단). 실패 시 throw → fork.js가 사용자 보고.
+    execFileSync('git', ['-C', mainWtPath, 'worktree', 'add', wtPath, '-b', branch, parent], {
       stdio: 'pipe',
     });
-    return { taskNum, nnn, branch, wtPath, projectId };
+    return { taskNum, nnn, branch, wtPath, projectId, parent };
   });
 }
 
@@ -434,12 +439,15 @@ const BACKLOG_PLACEHOLDER =
 function getActiveVersion(mainWtPath) {
   // .project/AGENT-GUIDE.md '## 활성 plan 버전' 섹션 다음 비어 있지 않은 첫 줄에서 활성 plan 식별자 추출.
   // plan = 기능 그룹 단위 → 식별자는 vX.X 버전명 또는 기능 그룹 slug(compare-products 등) 모두 가능.
+  // 헤딩 줄 끝 부가 텍스트(HTML 주석 등) 허용 — project-init 골격이 헤딩에 주석을 달므로
+  // 접두 일치로 판정(_setActivePlan의 findIndex 기준과 동일). 완전 일치 요구 시
+  // 자기 골격을 자기가 못 읽는 자기모순 (recordion FRICTION 2026-08-06, scaffoldError 6회).
   const guidePath = path.join(mainWtPath, '.project', 'AGENT-GUIDE.md');
   if (!fs.existsSync(guidePath)) {
     throw new Error(`.project/AGENT-GUIDE.md 부재. /project-init 먼저 호출.`);
   }
   const content = fs.readFileSync(guidePath, 'utf8');
-  const sec = content.match(/##\s*활성 plan 버전\s*\n+([^\n]+)/);
+  const sec = content.match(/^##\s*활성 plan 버전[^\n]*\n+([^\n]+)/m);
   if (!sec) {
     throw new Error(`.project/AGENT-GUIDE.md '## 활성 plan 버전' 섹션 부재.`);
   }
@@ -593,7 +601,7 @@ async function markBacklogChecked(mainWtPath, blId, taskNum) {
 }
 
 // ─── task 헤더 / 상태 전이 (코드화) ─────────────────────────────────
-// 헤더 5컬럼 파싱 · task 문서 위치 판정 · 7상태 유효전이 검증을 코드로 단일화.
+// 헤더 파싱(6컬럼 · 구 5컬럼 폴백) · task 문서 위치 판정 · 7상태 유효전이 검증을 코드로 단일화.
 // 계약: TASK_DOC_RULE §1.1(헤더) · §1.2(7상태) · §1.5(문서 위치).
 
 // 7×7 유효전이표 (TASK_DOC_RULE §1.2 + FAIL/UNCERTAIN 분기). from → 허용 to 목록.
@@ -639,7 +647,10 @@ function _locateHeaderRow(content) {
 }
 
 function parseTaskHeader(taskMdPath) {
-  // 헤더 5컬럼을 구조화 → { created, plan, type, size, status }. 표 부재/컬럼 부족 시 throw.
+  // 헤더를 구조화 → { created, plan, type, size, parent, status }. 표 부재/컬럼 부족 시 throw.
+  // 6컬럼(0.6.0+): 생성일·플랜·유형·규모·부모 브랜치·상태. 부모 브랜치는 상태 *앞* — 상태를
+  // 항상 마지막 셀로 유지해 setStatus의 `length-2` 로직이 구·신 양쪽에서 성립하게 함.
+  // 5컬럼(구): 부모 칸 부재 → parent='dev' 폴백(0.6.0 이전 문서 하위호환).
   const content = fs.readFileSync(taskMdPath, 'utf8');
   const loc = _locateHeaderRow(content);
   if (!loc) throw new Error(`헤더 표 파싱 실패 (TASK_DOC_RULE §1.1 형식 아님): ${taskMdPath}`);
@@ -647,13 +658,17 @@ function parseTaskHeader(taskMdPath) {
   if (inner.length < 5) {
     throw new Error(`헤더 표 컬럼 부족(${inner.length}/5): ${taskMdPath}`);
   }
+  if (inner.length >= 6) {
+    const [created, plan, type, size, parent, status] = inner;
+    return { created, plan, type, size, parent, status };
+  }
   const [created, plan, type, size, status] = inner;
-  return { created, plan, type, size, status };
+  return { created, plan, type, size, parent: 'dev', status };
 }
 
 function isProjectRegistered(mainWtPath) {
   // .gitignore에 .project/ 등록 여부 — check-ignore exit 0 = 등록(퍼블릭 default, 문서는 메인WT 공유),
-  // exit 1 = 미등록(문서는 워크트리 안, 머지로 dev 반영). task-init Step7 분기와 동일 판정.
+  // exit 1 = 미등록(문서는 워크트리 안, 머지로 부모 반영). task-init Step7 분기와 동일 판정.
   try {
     execFileSync(
       'git',
@@ -719,7 +734,8 @@ async function setStatus(taskMdPath, next) {
     const content = fs.readFileSync(taskMdPath, 'utf8');
     const loc = _locateHeaderRow(content);
     if (!loc) throw new Error(`헤더 표 파싱 실패: ${taskMdPath}`);
-    const cur = loc.cells.slice(1, -1).map((c) => c.trim())[4];
+    const trimmed = loc.cells.slice(1, -1).map((c) => c.trim());
+    const cur = trimmed[trimmed.length - 1]; // 상태 = 항상 마지막 셀 (6컬럼: 부모 브랜치가 그 앞)
     if (cur === next) return { changed: false, from: cur, to: next, path: taskMdPath };
     const allowed = TRANSITIONS[cur] || [];
     if (!allowed.includes(next)) {
@@ -767,14 +783,14 @@ function _buildTaskDocPath(base, plan, { taskNum, slug, promoted }) {
   return { dir: planDir, file: path.join(planDir, `${nnn}_${slug}.md`) };
 }
 
-function _renderTaskSkeleton({ taskNum, title, created, plan, docType, size }) {
+function _renderTaskSkeleton({ taskNum, title, created, plan, docType, size, parent }) {
   const nnn = String(taskNum).padStart(3, '0');
   return [
     `# TASK-${nnn} — ${title}`,
     '',
-    '| 생성일 | 플랜 | 유형 | 규모 | 상태 |',
-    '|--------|------|------|------|------|',
-    `| ${created} | ${plan} | ${docType} | ${size} | draft |`,
+    '| 생성일 | 플랜 | 유형 | 규모 | 부모 브랜치 | 상태 |',
+    '|--------|------|------|------|-------------|------|',
+    `| ${created} | ${plan} | ${docType} | ${size} | ${parent} | draft |`,
     '',
     '## Requirements',
     '',
@@ -800,14 +816,16 @@ function _renderTaskSkeleton({ taskNum, title, created, plan, docType, size }) {
 }
 
 function scaffoldTaskDoc(mainWtPath, wtPath, meta) {
-  // meta: { taskNum, slug, title, type(브랜치 타입), size, plan?, promoted?, created? }
+  // meta: { taskNum, slug, title, type(브랜치 타입), size, parent, plan?, promoted?, created? }
   // 위치: 등록(.gitignore) 케이스 → 메인WT, 미등록 → 워크트리. plan 미지정 시 AGENT-GUIDE에서 검출.
+  // parent 미지정 시 현재 브랜치 캡처(단독 호출 안전망 — 통상 fork가 넘김).
   // taskNum이 고유(fork init 락 채번)라 동일 문서 동시 쓰기 경합 없음 → 락 불요.
   const registered = isProjectRegistered(mainWtPath);
   const base = registered ? mainWtPath : wtPath;
   const plan = meta.plan || getActiveVersion(mainWtPath);
   const docType = DOC_TYPE_OF[meta.type] || meta.type;
   const created = meta.created || _todayLocal();
+  const parent = meta.parent || currentBranch(mainWtPath);
   const { dir, file } = _buildTaskDocPath(base, plan, {
     taskNum: meta.taskNum,
     slug: meta.slug,
@@ -826,6 +844,7 @@ function scaffoldTaskDoc(mainWtPath, wtPath, meta) {
       plan,
       docType,
       size: meta.size,
+      parent,
     }),
   );
   return { registered, promoted: !!meta.promoted, plan, file };
@@ -934,7 +953,7 @@ function initPlan(mainWtPath, slug, opts = {}) {
 
 // ─── task close 결정적 준비 (코드화, D1·D2) ─────────────────────────
 // closeTask는 *결정적 준비만* 수행: 게이트(status=tested) → Phase 커밋(D2) → status=closed →
-// flows/문서 커밋 → 추적마커. 비가역 3종(dev --no-ff 머지 · worktree remove · branch -d)과
+// flows/문서 커밋 → 추적마커. 비가역 3종(부모 브랜치 --no-ff 머지 · worktree remove · branch -d)과
 // 충돌 해결·머지 락은 스킬(LLM)이 수행 — 위험 최소화 + 충돌은 LLM 판단 영역.
 
 // 브랜치 타입 → 커밋 태그 (GIT_RULE 6-3).
@@ -991,10 +1010,26 @@ function _porcelainFiles(wtPath) {
     .filter(Boolean);
 }
 
+// 빌드 산출물 판정 — 소스 변경에 도구가 따라 바꾸는 파생 파일 (Phase 소속을 묻는 것 자체가 무의미).
+// Dev Plan에 명시 안 돼도 미매핑 blocked 대신 마지막 Phase에 자동 편입 (stash·recordion FRICTION: pbxproj 미매핑만 6회).
+const BUILD_ARTIFACT_RE = [
+  /\.pbxproj$/,
+  /(^|\/)package-lock\.json$/,
+  /(^|\/)yarn\.lock$/,
+  /(^|\/)pnpm-lock\.yaml$/,
+  /(^|\/)Cargo\.lock$/,
+  /(^|\/)Gemfile\.lock$/,
+  /(^|\/)Podfile\.lock$/,
+];
+
 function splitUncommittedByPhase(wtPath, taskMdPath, meta) {
   // 코드 변경분(.project/ 외)을 Dev Plan Phase에 매핑해 Phase별 자동 커밋. meta: { taskNum, type }.
-  //   - 모든 코드 파일이 정확히 1 Phase에 매핑 → Phase 순서대로 자동 커밋.
-  //   - 미매핑/다중매핑/Phase 파싱 불가 → { ambiguous } 반환(커밋 X) → 스킬이 수동 처리.
+  // 매핑 폴백 3규칙 (stash 6회 + recordion 5회 blocked 마찰 반영 — 11회 전부 기계적 편입이었음):
+  //   1. 다중 Phase 매핑 → 가장 이른 Phase에 편입 + 커밋 메시지에 '(Phase a·b 변경 포함)' 표기.
+  //      뒤 Phase가 앞 Phase 타입·함수를 참조하므로 이른 쪽이 의존 방향과 일치. 중간 커밋 독립 빌드는 비보장(GIT_RULE 명문).
+  //   2. 미매핑 + 빌드 산출물(BUILD_ARTIFACT_RE) → 매핑된 그룹 중 마지막 Phase(없으면 Dev Plan 마지막)에
+  //      자동 편입 + '(빌드 산출물 자동 편입)' 표기.
+  //   3. 미매핑 + 일반 파일 → { ambiguous } 반환(커밋 X) — 계획 누락 가능성이라 사람 판단으로 유지.
   // .project/ 메타(flows/문서/changelog)는 제외 — closeTask가 별도 커밋.
   const codeFiles = _porcelainFiles(wtPath).filter((f) => !f.startsWith('.project/'));
   if (codeFiles.length === 0) return { committed: [], empty: true };
@@ -1013,21 +1048,44 @@ function splitUncommittedByPhase(wtPath, taskMdPath, meta) {
       )
       .map(({ i }) => i);
   const fileToPhase = {};
+  const multiPhase = []; // 규칙 1 적용분 — { file, phases:[num...], assignedTo }
+  const artifactFiles = []; // 규칙 2 후보 — 매핑 확정 후 편입 Phase 결정
   for (const f of codeFiles) {
     const m = matchOf(f);
-    if (m.length !== 1) {
+    if (m.length === 1) {
+      fileToPhase[f] = m[0];
+    } else if (m.length > 1) {
+      const earliest = Math.min(...m);
+      fileToPhase[f] = earliest;
+      multiPhase.push({ file: f, phases: m.map((i) => phases[i].num), assignedTo: phases[earliest].num });
+    } else if (BUILD_ARTIFACT_RE.some((re) => re.test(f))) {
+      artifactFiles.push(f);
+    } else {
       return {
         ambiguous: true,
-        reason: m.length === 0 ? `Phase 미매핑: ${f}` : `다중 Phase 매핑: ${f}`,
+        reason: `Phase 미매핑: ${f}`,
         files: codeFiles,
         phases: phases.map((p) => ({ num: p.num, name: p.name, files: p.files })),
       };
     }
-    fileToPhase[f] = m[0];
   }
+  // 규칙 2 — 산출물 편입: 매핑된 그룹 중 마지막 Phase, 하나도 없으면 Dev Plan 마지막 Phase
+  const autoAssigned = [];
+  if (artifactFiles.length > 0) {
+    const mappedIdx = Object.values(fileToPhase);
+    const lastIdx = mappedIdx.length > 0 ? Math.max(...mappedIdx) : phases.length - 1;
+    for (const f of artifactFiles) {
+      fileToPhase[f] = lastIdx;
+      autoAssigned.push({ file: f, assignedTo: phases[lastIdx].num });
+    }
+  }
+  // 파일별 커밋 메시지 표기 (자동 편입의 근거를 커밋에 남김 — 코드가 몰래 정한 걸 드러낸다)
+  const noteOf = {};
+  for (const x of multiPhase) noteOf[x.file] = ` (Phase ${x.phases.join('·')} 변경 포함)`;
+  for (const x of autoAssigned) noteOf[x.file] = ' (빌드 산출물 자동 편입)';
   // Phase별 그룹 → 순서대로 커밋
   const groups = new Map();
-  for (const f of codeFiles) {
+  for (const f of Object.keys(fileToPhase)) {
     const i = fileToPhase[f];
     if (!groups.has(i)) groups.set(i, []);
     groups.get(i).push(f);
@@ -1041,28 +1099,36 @@ function splitUncommittedByPhase(wtPath, taskMdPath, meta) {
     execFileSync('git', ['-C', wtPath, 'add', '--', ...grp], { stdio: 'pipe' });
     const msg =
       `${tag}: [TASK-${nnn}] Phase ${p.num} - ${p.name}\n\n` +
-      grp.map((f) => `- ${f}`).join('\n') +
+      grp.map((f) => `- ${f}${noteOf[f] || ''}`).join('\n') +
       `\n- 사유: ${p.name}`;
     execFileSync('git', ['-C', wtPath, 'commit', '-m', msg], { stdio: 'pipe' });
     committed.push({ phase: p.num, name: p.name, files: grp });
   }
-  return { committed };
+  const result = { committed };
+  if (multiPhase.length > 0) result.multiPhase = multiPhase;
+  if (autoAssigned.length > 0) result.autoAssigned = autoAssigned;
+  return result;
 }
 
 async function closeTask(mainWtPath, { taskNum }, opts = {}) {
   // 결정적 준비만 — 비가역(머지·정리)·충돌 해결은 스킬이 후속 수행.
-  // 반환: { blocked } (게이트 미충족/매핑 모호) 또는 { prepped, branch, wtPath, registered, commits, aheadOfDev }.
+  // 반환: { blocked } (게이트 미충족/매핑 모호) 또는
+  //   { prepped, branch, parent, wtPath, registered, commits, aheadOfParent,
+  //     multiPhase?, autoAssigned? (매핑 폴백 적용 시 내역) }. parent = 스킬 머지 대상.
   const active = getActiveTasks(mainWtPath).find((t) => t.taskNum === taskNum);
   if (!active) {
     throw new Error(`TASK-${String(taskNum).padStart(3, '0')} 진행중 브랜치 없음 (SSoT 조회).`);
   }
-  assertMainWorktreeOnDev(mainWtPath);
   const projectId = getProjectId(mainWtPath);
   const wtPath = getWorktreePath(projectId, { taskNum, src: active.src, slug: active.slug });
   const resolved = resolveTaskDocPath(mainWtPath, wtPath, { taskNum });
   if (!resolved) throw new Error(`TASK-${taskNum} 문서 못 찾음.`);
 
   const header = parseTaskHeader(resolved.file);
+  // 부모 = 헤더 기록값(0.6.0, 구 문서는 'dev' 폴백). 메인 워크트리가 그 부모에 서 있어야
+  // 스킬 후속 머지가 올바른 브랜치로 간다.
+  const parent = header.parent;
+  assertMainWorktreeOn(mainWtPath, parent);
   if (header.status !== 'tested') {
     return { blocked: 'status', current: header.status, docPath: resolved.file };
   }
@@ -1114,9 +1180,9 @@ async function closeTask(mainWtPath, { taskNum }, opts = {}) {
     }
   }
 
-  // 추적 마커 빈커밋 (dev보다 앞선 커밋 0개 — docs/분석 task + .project gitignore 케이스)
+  // 추적 마커 빈커밋 (부모보다 앞선 커밋 0개 — docs/분석 task + .project gitignore 케이스)
   const ahead = parseInt(
-    gitCapture(wtPath, ['rev-list', '--count', 'dev..HEAD'], { allowFail: true }) || '0',
+    gitCapture(wtPath, ['rev-list', '--count', `${parent}..HEAD`], { allowFail: true }) || '0',
     10,
   );
   if (ahead === 0) {
@@ -1136,19 +1202,24 @@ async function closeTask(mainWtPath, { taskNum }, opts = {}) {
   }
 
   const aheadFinal = parseInt(
-    gitCapture(wtPath, ['rev-list', '--count', 'dev..HEAD'], { allowFail: true }) || '0',
+    gitCapture(wtPath, ['rev-list', '--count', `${parent}..HEAD`], { allowFail: true }) || '0',
     10,
   );
-  return {
+  const prepResult = {
     prepped: true,
     taskNum,
     branch: active.branch,
+    parent,
     wtPath,
     registered: resolved.registered,
     docPath: resolved.file,
     commits,
-    aheadOfDev: aheadFinal,
+    aheadOfParent: aheadFinal,
   };
+  // 매핑 폴백 적용 내역 노출 — 코드가 자동 편입한 걸 스킬·사용자가 볼 수 있게
+  if (split.multiPhase) prepResult.multiPhase = split.multiPhase;
+  if (split.autoAssigned) prepResult.autoAssigned = split.autoAssigned;
+  return prepResult;
 }
 
 module.exports = {
@@ -1187,8 +1258,8 @@ module.exports = {
   getInitLockPath,
   withMergeLock,
   withMetaLock,
-  assertDevExists,
-  assertMainWorktreeOnDev,
+  currentBranch,
+  assertMainWorktreeOn,
   parseBranchName,
   getActiveTasks,
   getNextTaskNumber,

package/bin/mcp.js

@@ -189,7 +189,7 @@ server.registerTool(
     inputSchema: {
       type: z.enum(VALID_TYPES),
       dev: z.string().describe('개발자 식별자 (claude / angar2 등)'),
-      src: z.string().regex(/^(BL-\d+|RM-\d+|DR)$/, 'BL-NNN | RM-NNN | DR'),
+      src: z.string().regex(/^(BL-\d+|RM-\d+|ST-\d+|DR)$/, 'BL-NNN | ST-N(로드맵 Stage) | DR (구형 RM-NNN 호환)'),
       slug: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, '영어 kebab-case'),
       size: z.enum(VALID_SIZES).optional(),
       title: z.string().optional().describe('한국어 제목 (size와 함께 주면 골격 생성)'),
@@ -213,6 +213,7 @@ server.registerTool(
           title: a.title,
           type: a.type,
           size: a.size,
+          parent: result.parent,
           promoted: !!a.promote,
         });
         out = { ...result, docPath: doc.file, registered: doc.registered, promoted: doc.promoted };
@@ -228,7 +229,7 @@ server.registerTool(
   'task_close',
   {
     description:
-      'close 결정적 준비만 — Phase 커밋·status=closed·문서 커밋·추적마커. 게이트(status=tested)·매핑 모호 시 blocked 반환. 비가역(dev --no-ff 머지·worktree/branch 정리·충돌 해결)은 스킬(task-close)이 후속 수행.',
+      'close 결정적 준비만 — Phase 커밋·status=closed·문서 커밋·추적마커. 게이트(status=tested)·매핑 모호 시 blocked 반환. 반환 parent = 스킬 머지 대상 부모 브랜치. 비가역(부모 --no-ff 머지·worktree/branch 정리·충돌 해결)은 스킬(task-close)이 후속 수행.',
     inputSchema: { task: z.union([z.string(), z.number()]).describe('TASK-NNN 또는 번호') },
   },
   handler(async (a) => {
@@ -245,7 +246,7 @@ server.registerTool(
         `Phase↔파일 매핑 모호 (${result.reason}) — Dev Plan '파일' 필드 확인 후 수동 Phase 커밋 → task_close 재호출.`,
       );
     }
-    return ok(result, `prep 완료. 비가역(사전 rebase·충돌해결·머지 락·dev 머지·정리)은 task-close 스킬이 후속 수행.`);
+    return ok(result, `prep 완료 (부모=${result.parent}). 비가역(사전 rebase·충돌해결·머지 락·부모 --no-ff 머지·정리)은 task-close 스킬이 후속 수행.`);
   }),
 );
 

package/bin/status.js

@@ -56,11 +56,14 @@ function main() {
   const lockTimeoutMs = manifest.lock_timeout_ms ?? DEFAULT_LOCK_TIMEOUT_MS;
 
   const currentBranch = gitCapture(mainWt, ['rev-parse', '--abbrev-ref', 'HEAD']);
-  const isOnDev = currentBranch === 'dev';
+  const detached = currentBranch === 'HEAD';
 
   console.log(`\ntaskery status\n`);
   console.log(`메인 워크트리: ${mainWt}`);
-  console.log(`현재 브랜치: ${currentBranch}${isOnDev ? '' : ' ⚠ (메인 워크트리 = dev 정책 위배)'}`);
+  // 현재 브랜치 = 새 태스크의 부모 브랜치(0.6.0). detached HEAD면 fork 불가.
+  console.log(
+    `현재 브랜치(= 새 태스크 부모): ${currentBranch}${detached ? ' ⚠ (detached HEAD — 브랜치 체크아웃 필요)' : ''}`,
+  );
   console.log(`projectId: ${projectId}`);
   console.log(`stale_days: ${staleDays} / lock_timeout_ms: ${lockTimeoutMs}\n`);
 
@@ -126,7 +129,7 @@ function main() {
     );
     const orphans = folders.filter((f) => !activeFolders.has(f));
     if (orphans.length > 0) {
-      console.log(`⚠ SSoT에 없는 워크트리 폴더 ${orphans.length}건 (이미 dev 머지된 잔존?):`);
+      console.log(`⚠ SSoT에 없는 워크트리 폴더 ${orphans.length}건 (이미 부모 머지된 잔존?):`);
       for (const o of orphans) {
         console.log(`  ${path.join(worktreesRoot, o)}`);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angar2/taskery",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Lightweight task system for Claude Code & Codex — 1 메인 세션(또는 멀티세션) + 스킬 9종 + catastrophic hook 안전망 2종",
   "bin": {
     "taskery": "bin/taskery.js",

package/template/.claude/hooks/closed-immutable.sh

@@ -48,7 +48,9 @@ if [ ! -f "$TASK_MD" ]; then
   exit 0
 fi
 
-# 헤더 status 추출 (5컬럼 표 — 생성일 / 플랜 / 유형 / 규모 / 상태)
+# 헤더 status 추출 — status는 헤더 표의 *마지막* 셀.
+#   5컬럼(구): 생성일 / 플랜 / 유형 / 규모 / 상태
+#   6컬럼(0.6.0+): 생성일 / 플랜 / 유형 / 규모 / 부모 브랜치 / 상태
 # python3 정규식 사용 (mac BSD grep -P 미지원)
 STATUS=$(TM="$TASK_MD" python3 -c "
 import os, re
@@ -59,8 +61,8 @@ except Exception:
     raise SystemExit(0)
 # 7-state whitelist
 WL = r'(draft|planned|developing|developed|testing|tested|closed)'
-# 5-column row: | 생성일 | 플랜 | 유형 | 규모 | 상태 |
-m = re.search(rf'^\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|\s*{WL}\s*\|\s*\$', content, re.MULTILINE)
+# status = 마지막 셀. 선행 셀 4개(구 5컬럼) 또는 5개(신 6컬럼) 뒤에 온다.
+m = re.search(rf'^\|(?:[^|]*\|){{4,5}}\s*{WL}\s*\|\s*\$', content, re.MULTILINE)
 print(m.group(1) if m else '')
 " 2>/dev/null)
 

package/template/.codex/agents/task-tester.toml

@@ -24,9 +24,12 @@ developer_instructions = """
 - task.md의 ## Test Plan 시나리오를 순서대로 그대로 수행한다(임의 추가/스킵/변형 금지).
 - 문 앞 검사(먼저) — 각 [AUTO] 시나리오가 [실행 명령/입력 + 구체적·관측 가능한 기대값(출력값/상태코드/어서션/조회 결과/화면 상태)] 한 쌍을 갖췄는지 확인한다. "정상 동작/잘 됨/확인한다" 같은 소원은 기대값이 아니다. 미달인 [AUTO]는 검사하지 말고 "시험문제 결함(검증 불가)"으로 분류 + 무엇이 빠졌는지 지목한다(PASS 반올림 금지).
 - 증거 일치 시만 PASS — 자격 갖춘 [AUTO]는 실제로 실행해 *관측 결과가 기대값과 일치할 때만* PASS. 코드 정독 "그럴듯함"·추정으로 PASS 금지. 증거(명령 출력/응답 로그/캡처/조회 결과)를 첨부한다.
-- [AUTO]/[USER] 분류 — [USER]는 정답지가 *주관*인 것만(시각 미세 취향 / 색조·2px / UX 느낌) → UNCERTAIN(사람 검수) + 증거 캡처로 리턴. 시각 *객관* 깨짐(요소 빠짐/빈 화면/배치 딴판/색 완전히 틀림)은 [USER]가 아니라 [AUTO] — 실제 화면 캡처 → 승인 목업과 대조해 네가 직접 판정한다(어긋나면 *구체적 어긋남 목록* + FAIL). 시각이라고 무조건 사람에게 넘기지 마라.
-- UNCERTAIN 두 종류 — (사람 검수)=정답지가 주관인 영역 / (검증 불가)=[AUTO]인데 대조할 기대값을 구성 못 함=시험문제 결함. 검증 불가는 PASS로 반올림하거나 사람 검수로 떠넘기지 말고, *무엇을 시도했고 왜 기대값을 구성할 수 없는지* 근거를 반드시 기록한다(task-plan으로 Test Plan을 보수해야 하는 신호).
+- [AUTO]/[USER] 분류 — [USER]는 정답지가 *주관*인 것만(시각 미세 취향 / 색조·2px / UX 느낌) → UNCERTAIN(사람 검수) + 증거 캡처로 리턴. 시각 *객관* 깨짐(요소 빠짐/빈 화면/배치 딴판/색 완전히 틀림)은 [USER]가 아니라 [AUTO] — 실제 화면 캡처 → 승인 목업과 대조해 네가 직접 판정한다(어긋나면 *구체적 어긋남 목록* + FAIL). 시각이라고 무조건 사람에게 넘기지 마라. 단 시각 객관의 [AUTO] 승격은 TEST-GUIDE의 *시각 실행* 절에 캡처 실행 경로가 있을 때 한정이다 — 경로가 없어 task.md가 [USER]로 분류했으면 그 분류를 존중한다.
+- UNCERTAIN 세 종류 — (사람 검수)=정답지가 주관인 영역 / (검증 불가)=[AUTO]인데 대조할 기대값을 구성 못 함=시험문제 결함 / (실행 보류)=화면·입력 점유 제약으로 실행하지 않음=환경 제약(사용자 승인 또는 격리 실행 경로 필요. 무엇을 왜 실행하지 않았는지 기록해 리턴). 검증 불가는 PASS로 반올림하거나 사람 검수로 떠넘기지 말고, *무엇을 시도했고 왜 기대값을 구성할 수 없는지* 근거를 반드시 기록한다(task-plan으로 Test Plan을 보수해야 하는 신호).
 - 신규 테스트 추가 시 카운트 +N / 모든 PASS만으로 단정 X — 신규 *테스트 식별자*(suite/class/function 등)가 runner 로그에 실제 등장했는지 grep으로 확인한다(1 hit 이상, 없으면 Suite 미실행 → FAIL). grep/Read 존재 확인은 보조용 — 실동작 PASS를 대체할 수 없다.
+- 픽스처 현실성 — 픽스처·시드가 실제 산출물과 형식·정밀도가 같은지 의심하고, 의심되면 실제 코드(writer·생성기)로 재생성해 재실행한 결과로 판정한다. 재생성 경로가 없어 대조를 구성할 수 없으면 시험문제 결함(검증 불가)으로 분류한다.
+- 어서션 정면성 — 기대값이 요구사항을 정면으로 겨누는지 확인한다("벗어날 수 없다"면 실제로 벗어나 볼 것. 버튼 disabled 확인은 우회 지표다). 우회 지표로 검사하는 [AUTO] 시나리오는 시험문제 결함으로 분류하고 무엇이 정면 관측인지 지목한다.
+- 화면·입력 점유 금지 — 실제 앱을 띄워 UI를 자동 조작하는 스위트는 사용자의 화면·입력을 점유한다. TEST-GUIDE의 *테스트 실행 환경* 절에 격리 실행 경로(창 숨김·헤드리스 / 컨테이너 / VM / CI)가 있으면 그 경로로 실행하고, 없으면 비점유 부분만 실행하거나 실행 보류(사용자 승인 필요)로 표시해 리턴한다. 헤드리스 모드가 있으면 항상 그쪽을 쓴다.
 - 코드와 동작만 신뢰한다. 코드 파일 수정 금지. 임시 파일(테스트 스크립트 등)은 종료 후 삭제한다.
-- 검증을 마치면 넘겨받은 검사 지시의 결과 형식(종합 판정 PASS/FAIL/UNCERTAIN / 시나리오별 결과 / 검증·테스트 명령 결과 / UNCERTAIN 2종 / 시험문제 결함)을 그대로 리턴한다.
+- 검증을 마치면 넘겨받은 검사 지시의 결과 형식(종합 판정 PASS/FAIL/UNCERTAIN / 시나리오별 결과 / 검증·테스트 명령 결과 / UNCERTAIN 3종 / 시험문제 결함 / 실행 보류)을 그대로 리턴한다.
 """