leerness 1.9.276 → 1.9.278

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## 1.9.278 — 2026-06-03 — UR-0032: .leerness/ JSON 상태 스키마 (범용 하네스 substrate 1단계)
+
+**🧱 GPT-5.5 가 최우선으로 꼽은 "상태 스키마" — 에이전트 간 구조화 인수인계 substrate. 마크다운(.harness)과 병행, 비파괴.**
+
+### 배경
+GPT-5.5: "범용 하네스가 되려면 파일 생성 도구가 아니라 프로토콜/상태 관리 도구가 돼야 한다. `.leerness/` JSON 스키마(runs/state/decisions)에 task_id/agent/model/files_changed/verification/handoff 가 있어야 Claude Code 작업을 Goose 가 이어받는다." → 전략 백로그 중 substrate 라서 **최우선** 구현.
+
+### 구현
+1. **`.leerness/` 상태 디렉토리** (신규, 비파괴 — 기존 `.harness` markdown 과 병행).
+2. **`_newRunRecord()` 순수 스키마 빌더** — GPT-5.5 권고 14필드: `schemaVersion/run_id/task_id/agent_name/model_name/started_at/ended_at/goal/files_read/files_changed/commands_run/tests_run/errors/decisions/verification_result/handoff_summary/status`.
+3. **`leerness state <show|start|record|verify|handoff>`** CLI (전 서브 `--json`):
+   - `start "<goal>" [--agent --model --task]` → `runs/run-NNNN.json` 생성 + `state.json` currentRun 갱신
+   - `record --files-changed/--commands/--tests/--decision/...` → 배열 누적(dedup)
+   - `verify --result pass|fail` → verification_result + status
+   - `handoff "<summary>"` → ended_at/status=handed-off + **`.leerness/handoff/latest.{md,json}`** (다음 에이전트 인수) + currentRun 해제
+   - `show [--json]` → 현재 상태 + 진행 run
+4. **selftest 27→28 + e2e 224→225** — 스키마 14필드 + 전체 라이프사이클(start→record→verify→handoff→show) JSON 인수인계 검증.
+
+### 다음 단계 (전략 백로그 연계)
+- UR-0031: 이 스키마를 MCP 시맨틱 verb(get_context/record_decision/verify_done/make_handoff)로 노출.
+- UR-0033: `leerness adapter` 가 도구별로 이 substrate 를 가리키게.
+
+### 검증
+- **selftest 28/28 PASS** · **E2E 225/225 PASS** (회귀 0) · 라이프사이클 실측(.leerness/state·runs·handoff 생성, 다음 에이전트 JSON 인수).
+
+## 1.9.277 — 2026-06-03 — 신규 provider 4종(opencode/qwen/aider/goose) + GPT-5.5 범용 하네스 방향 백로그 등록
+
+**🤝 CLI 에이전트 4종을 정식 provider 로 추가 (설치 선택지 + 모델 catalog + dispatch/roles 라우팅). 빌트인 6 → 10종.**
+
+### 신규 provider (사용자 명시)
+1. **EXTERNAL_AGENTS +4** — `opencode`(오픈소스 터미널 에이전트) · `qwen`(Qwen Code) · `aider`(git-aware 페어프로그래밍) · `goose`(Block 범용 에이전트, MCP 확장). 각 `bin`/`envFlag`/`installCmd` 포함.
+2. **자동 전파** — provider list(10)/cycle/setup-agents/`agents dispatch`/`roles`/`slash-commands` 가 4종 자동 흡수.
+3. **install 흐름 10선택지** — 대화형 `_selectMany` + 비대화형 `1~10` 맵 확장.
+4. **모델 catalog** — opencode(default/anthropic/openai) · qwen(qwen3-coder-plus/max/plus/turbo) · aider(sonnet/gpt-5/deepseek/o1-mini) · goose(default/claude/gpt).
+5. **`_dispatchCommand`** — `opencode run` · `qwen -p` · `aider --message [--yes]` · `goose run -t` (모델 플래그 주입, best-effort).
+6. **슬래시 레지스트리** — 4종 세션 슬래시/명령 큐레이션(opencode/qwen/aider/goose).
+7. **config/nonsecret 키** — `LEERNESS_ENABLE_OPENCODE/QWEN/AIDER/GOOSE`.
+
+### GPT-5.5 "범용 하네스 성장 방향" 판단 → 작업 스케줄 등록
+GPT-5.5: leerness 는 실행 에이전트(Goose 등)와 경쟁하지 말고, 그들이 공통 의존하는 **운영 레이어(Memory+Policy+Handoff+Verification+Audit)**가 되면 범용 하네스로 성장 가능. **판단: 방향 타당 — leerness 는 이미 MCP 75도구/handoff/capabilities 로 상당 부분 정합**. 적용 항목을 백로그 등록:
+- **UR-0030** 운영 레이어 정체성 포지셔닝 (실행기 경쟁 지양)
+- **UR-0031** MCP 시맨틱 verb 정비 (get_context/start_task/record_decision/verify_done/make_handoff …)
+- **UR-0032** `.leerness/` JSON 상태 스키마 (runs/tasks/decisions — 에이전트 간 인수인계 표준)
+- **UR-0033** `leerness adapter <tool>` 도구별 선택 생성 (--minimal 확장)
+- **UR-0034** 권한 등급 enforced (read-only…publish, 기본 보수적) — capabilities 확장
+- **UR-0035** AGENTS.md(정적) vs leerness(동적) 역할 분리 포지셔닝
+
+### 검증
+- **selftest 27/27 PASS** · **E2E 224/224 PASS** (회귀 0) — agents list/quota 10 CLI · provider list 10.
+
 ## 1.9.276 — 2026-06-03 — 설치 부담 완화: init --dry-run / --minimal / --no-env (GPT-5.5 2차 리뷰)
 
 **📦 GPT-5.5 2차 외부 평가(7/10)의 핵심 지적 "init이 너무 침투적 + 미리보기 부재"를 직접 해결.**

package/README.md

@@ -3,7 +3,7 @@
 > **AI 코딩 에이전트의 거짓 완료·중복·망각·충돌을 막아주는 검수·기억·협업 CLI 하네스.**
 > **A CLI harness that stops AI coding agents from faking completion, duplicating work, forgetting context, and colliding.**
 
-[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.276-green)]() [![tests](https://img.shields.io/badge/e2e-224%2F224-success)]() [![selftest](https://img.shields.io/badge/selftest-24%2F24-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-75-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-6-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
+[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.278-green)]() [![tests](https://img.shields.io/badge/e2e-225%2F225-success)]() [![selftest](https://img.shields.io/badge/selftest-24%2F24-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-75-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-10-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -28,7 +28,7 @@
 
 ## 한눈에 보기
 
-`leerness`는 **Claude Code · Cursor · Copilot · Codex · Antigravity · Grok** 같은 AI 코딩 에이전트와 함께 일할 때 생기는 구조적 문제를 자동으로 막아주는 CLI 도구입니다.
+`leerness`는 **Claude Code · Cursor · Copilot · Codex · Antigravity · Grok · opencode · Qwen · Aider · Goose** 같은 AI 코딩 에이전트와 함께 일할 때 생기는 구조적 문제를 자동으로 막아주는 CLI 도구입니다.
 
 AI는 코드를 빠르게 쓰지만, 다음 **5가지 함정**에 반복해서 빠집니다 — leerness는 이를 모두 자동으로 감지·차단·회복합니다.
 
@@ -139,7 +139,7 @@ leerness session close [path]        # 세션 마감 + 다음 세션 인계
 leerness drift check [path]          # leerness 미사용 drift 점수
 
 # 멀티 AI 에이전트 · 역할
-leerness setup-agents                # 활성화 (claude/codex/agy/grok/copilot/ollama)
+leerness setup-agents                # 활성화 (claude/codex/agy/grok/opencode/qwen/aider/goose/copilot/ollama)
 leerness agents list | quota         # 상태 / 한도
 leerness agents dispatch "<task>" --role coder   # 역할 기반 모델 라우팅
 leerness agents bench "<task>"       # 여러 CLI 동시 호출 + 비교
@@ -215,7 +215,7 @@ leerness release channel  # 현재 채널/정책 확인 (--json)
 
 ## At a glance
 
-`leerness` is a CLI harness that automatically prevents the structural problems that arise when working with AI coding agents like **Claude Code · Cursor · Copilot · Codex · Antigravity · Grok**.
+`leerness` is a CLI harness that automatically prevents the structural problems that arise when working with AI coding agents like **Claude Code · Cursor · Copilot · Codex · Antigravity · Grok · opencode · Qwen · Aider · Goose**.
 
 AI writes code fast, but repeatedly falls into **5 traps** — leerness detects, blocks, and recovers from all of them.
 
@@ -326,7 +326,7 @@ leerness session close [path]        # close session + hand off
 leerness drift check [path]          # leerness-disuse drift score
 
 # Multi AI agents · roles
-leerness setup-agents                # enable (claude/codex/agy/grok/copilot/ollama)
+leerness setup-agents                # enable (claude/codex/agy/grok/opencode/qwen/aider/goose/copilot/ollama)
 leerness agents list | quota         # status / limits
 leerness agents dispatch "<task>" --role coder   # role-based model routing
 leerness agents bench "<task>"       # call several CLIs at once + compare
@@ -440,7 +440,7 @@ MIT — © leerness contributors
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.9.276 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.9.278 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### Core Commands
 
@@ -482,7 +482,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.9.276는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **42개 도구**를 노출:
+Leerness v1.9.278는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **42개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -503,7 +503,7 @@ Leerness v1.9.276는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) stress-v* 신규 작성 + 누적 회귀 → 4) e2e 219/219 → 5) npm pack + git tag + GitHub release → 6) main 자동 push (1.9.140+) → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **70 라운드 (1.9.40 → 1.9.276)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
+현재 누적: **70 라운드 (1.9.40 → 1.9.278)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
 
 ### 성능 가이드 (1.9.140 측정)
 
@@ -541,6 +541,6 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.9.276: 2026-06-03
+Last synced by Leerness v1.9.278: 2026-06-03
 <!-- leerness:project-readme:end -->
 

package/bin/harness.js

@@ -9,7 +9,7 @@ const readline = require('readline');
 // 1.9.274 (UR-0025 1단계): 순수 유틸 함수 모듈 분리 (require-based, 비파괴). selftest 7종이 동작 검증.
 const { _isSecretKey, compareVer, parseHarnessVersion, _classifyCJK, _riskLabel, _detectSystemLang, _parseSlashFromHelp } = require('../lib/pure-utils');
 
-const VERSION = '1.9.276';
+const VERSION = '1.9.278';
 
 // 1.9.184: DEP0190 (child_process shell: true) deprecation warning 억제 (사용자 명시).
 //   leerness 는 cross-platform PATH resolution 을 위해 shell: true 를 의도적으로 사용 (claude.cmd / ollama.cmd 등 Windows .cmd 처리).
@@ -866,19 +866,24 @@ async function resolveInstallOptions(root, opts = {}) {
         { label: 'Codex (OpenAI codex CLI)', description: 'OpenAI 코드 모델', id: 'codex' },
         { label: 'Antigravity (agy CLI)', description: 'Google Antigravity 멀티모달 에이전트 (1.9.248~)', id: 'agy' },
         { label: 'Grok (xAI grok-cli)', description: 'xAI Grok CLI — grok-beta 등 (1.9.268~)', id: 'grok' },
+        { label: 'opencode', description: '오픈소스 터미널 AI 코딩 에이전트 (1.9.277~)', id: 'opencode' },
+        { label: 'Qwen Code (qwen)', description: 'Alibaba Qwen Code CLI (1.9.277~)', id: 'qwen' },
+        { label: 'Aider', description: 'git-aware 페어 프로그래밍 CLI (1.9.277~)', id: 'aider' },
+        { label: 'Goose (Block)', description: '오픈소스 범용 로컬 AI 에이전트 — MCP 확장 (1.9.277~)', id: 'goose' },
         { label: 'Copilot (gh extension)', description: 'GitHub Copilot CLI', id: 'copilot' },
         { label: 'Ollama (로컬 LLM — llama3/qwen 등)', description: 'http://localhost:11434 — 무료/오프라인', id: 'ollama' }
       ], { defaults: [] });
       agentsOptIn = picked.length ? picked.map(p => p.id) : 'none';
     } else {
       log('\nCLI 에이전트 활성화 (복수 선택 — 콤마로 구분, opt-in):');
-      log('  1) claude  2) codex  3) agy (Antigravity)  4) grok (xAI)  5) copilot  6) ollama  (예: 1,6 또는 all 또는 none)');
+      log('  1) claude  2) codex  3) agy  4) grok  5) opencode  6) qwen  7) aider  8) goose  9) copilot  10) ollama  (예: 1,8 또는 all 또는 none)');
       const a = (await ask('선택 [none]: ')).trim().toLowerCase();
-      if (a === 'all') agentsOptIn = ['claude', 'codex', 'agy', 'grok', 'copilot', 'ollama'];
+      const ALL_IDS = ['claude', 'codex', 'agy', 'grok', 'opencode', 'qwen', 'aider', 'goose', 'copilot', 'ollama'];
+      if (a === 'all') agentsOptIn = ALL_IDS.slice();
       else if (!a || a === 'none' || a === '0') agentsOptIn = 'none';
       else {
-        const map = { '1': 'claude', '2': 'codex', '3': 'agy', '4': 'grok', '5': 'copilot', '6': 'ollama' };
-        const picks = a.split(/[,\s]+/).map(t => map[t] || (['claude','codex','agy','grok','copilot','ollama'].includes(t) ? t : null)).filter(Boolean);
+        const map = { '1': 'claude', '2': 'codex', '3': 'agy', '4': 'grok', '5': 'opencode', '6': 'qwen', '7': 'aider', '8': 'goose', '9': 'copilot', '10': 'ollama' };
+        const picks = a.split(/[,\s]+/).map(t => map[t] || (ALL_IDS.includes(t) ? t : null)).filter(Boolean);
         agentsOptIn = picks.length ? picks : 'none';
       }
     }
@@ -1071,6 +1076,10 @@ async function install(root, opts = {}) {
         LEERNESS_ENABLE_CODEX: enable('codex') ? '1' : '0',
         LEERNESS_ENABLE_AGY: enable('agy') ? '1' : '0',
         LEERNESS_ENABLE_GROK: enable('grok') ? '1' : '0',
+        LEERNESS_ENABLE_OPENCODE: enable('opencode') ? '1' : '0',
+        LEERNESS_ENABLE_QWEN: enable('qwen') ? '1' : '0',
+        LEERNESS_ENABLE_AIDER: enable('aider') ? '1' : '0',
+        LEERNESS_ENABLE_GOOSE: enable('goose') ? '1' : '0',
         LEERNESS_ENABLE_COPILOT: enable('copilot') ? '1' : '0',
         LEERNESS_ENABLE_OLLAMA: enable('ollama') ? '1' : '0',
         LEERNESS_SKILL_DISCOVER_URL: '',
@@ -2944,13 +2953,14 @@ function _selfTestCases() {
     { name: '_agentSlashHint: grok 슬래시 요약 + copilot 하위명령 라벨', run: () => { const g = _agentSlashHint('.', 'grok'); const c = _agentSlashHint('.', 'copilot'); return !!g && g.count > 0 && /Grok/.test(g.summary) && !!c && c.invoke === 'subcommand' && /하위명령/.test(c.summary); } },
     { name: '_parseSlashFromHelp: 슬래시 검출 + 플래그 제외 (1.9.267)', run: () => { const r = _parseSlashFromHelp('  /help   show help\n  /model  switch model\n  --version  print version\n', 'slash'); return r.length === 2 && r[0].cmd === '/help' && /show help/.test(r[0].desc) && !r.some(c => /version/.test(c.cmd)); } },
     { name: '_parseSlashFromHelp: subcommand 모드 들여쓰기 파싱 (1.9.267)', run: () => { const r = _parseSlashFromHelp('Commands:\n  suggest    제안\n  explain    설명\n', 'subcommand'); return r.length >= 2 && r.some(c => c.cmd === 'suggest') && r.some(c => c.cmd === 'explain'); } },
-    { name: 'EXTERNAL_AGENTS: grok 정식 provider 승격 (1.9.268)', run: () => { const g = EXTERNAL_AGENTS.find(a => a.id === 'grok'); return !!g && g.bin === 'grok' && g.envFlag === 'LEERNESS_ENABLE_GROK' && EXTERNAL_AGENTS.length === 6; } },
+    { name: 'EXTERNAL_AGENTS: 10종 (grok + opencode/qwen/aider/goose 포함) (1.9.277)', run: () => { const ids = EXTERNAL_AGENTS.map(a => a.id); return EXTERNAL_AGENTS.length === 10 && ['grok','opencode','qwen','aider','goose'].every(id => ids.includes(id)) && EXTERNAL_AGENTS.find(a => a.id === 'goose').envFlag === 'LEERNESS_ENABLE_GOOSE'; } },
     { name: '_detectSystemLang: POSIX LANG ko_KR/en_US 판별 (1.9.269)', run: () => _detectSystemLang({ LANG: 'ko_KR.UTF-8' }) === 'ko' && _detectSystemLang({ LANG: 'en_US.UTF-8' }) === 'en' },
     { name: '_detectSystemLang: LC_ALL 우선 + LANGUAGE 폴백 (1.9.269)', run: () => _detectSystemLang({ LC_ALL: 'ko_KR.UTF-8', LANG: 'en_US.UTF-8' }) === 'ko' && _detectSystemLang({ LANGUAGE: 'en_GB' }) === 'en' },
     { name: 'ROLE_CATALOG + _normalizeRole: 7종 + 한국어 별칭 (1.9.270)', run: () => { const keys = Object.keys(ROLE_CATALOG); return keys.length === 7 && keys.includes('coder') && keys.includes('reviewer') && _normalizeRole('코딩') === 'coder' && _normalizeRole('검수자') === 'reviewer' && _normalizeRole('지휘관') === 'commander'; } },
     { name: '_pickModel: top/code/fast 등급 선택 (1.9.270)', run: () => { return _pickModel('codex', 'code') === 'gpt-5-codex' && _pickModel('claude', 'top') === 'claude-opus-4-7' && /haiku/.test(_pickModel('claude', 'fast')); } },
     { name: 'CAPABILITY_SURFACE: 6 영역 + risk/optOut + 주의명령 (1.9.272)', run: () => { const ks = Object.keys(CAPABILITY_SURFACE); return ks.length === 6 && ks.includes('automationBridges') && Object.values(CAPABILITY_SURFACE).every(v => ['low','medium','high'].includes(v.risk) && v.optOut && v.desc) && POWERFUL_COMMANDS.length >= 5; } },
     { name: '_resolveNpmTag: latest 기본 + next 허용 + 잘못된 형식 폴백 (1.9.275)', run: () => _resolveNpmTag(null, {}) === 'latest' && _resolveNpmTag('next', {}) === 'next' && _resolveNpmTag(null, { LEERNESS_NPM_TAG: 'next' }) === 'next' && _resolveNpmTag('bad tag!', {}) === 'latest' && _resolveNpmTag('Beta', {}) === 'beta' },
+    { name: '_newRunRecord: GPT-5.5 권고 스키마 14필드 + 기본값 (1.9.278)', run: () => { const r = _newRunRecord({ run_id: 'run-0001', goal: 'g', started_at: '2026-06-03T00:00:00Z' }); return r.schemaVersion === 1 && r.run_id === 'run-0001' && r.started_at === '2026-06-03T00:00:00Z' && Array.isArray(r.files_changed) && Array.isArray(r.commands_run) && Array.isArray(r.tests_run) && Array.isArray(r.decisions) && r.verification_result === null && r.status === 'in-progress' && 'handoff_summary' in r && 'model_name' in r && 'task_id' in r; } },
     { name: 'coreFiles --minimal: 핵심 유지 + 비핵심 제외 + verify 필수 보존 (1.9.276)', run: () => { const full = coreFiles('.', 'ko', []); const min = coreFiles('.', 'ko', [], { minimal: true }); const keep = ['.harness/plan.md','.harness/progress-tracker.md','.harness/session-handoff.md','AGENTS.md','CLAUDE.md','.harness/consistency-policy.md','.harness/reuse-map.md','.harness/encoding-policy.md','.harness/secret-policy.md']; const drop = ['.cursor/rules/leerness.mdc','.harness/skill-index.md','.harness/architecture.md']; const verifyReq = ['.harness/design-system.md','.harness/protected-files.md','.harness/current-state.md']; if (!verifyReq.every(k => min[k])) return false; return Object.keys(min).length < Object.keys(full).length && keep.every(k => min[k]) && drop.every(k => !min[k]); } },
     { name: 'VERSION 형식 (x.y.z)', run: () => /^\d+\.\d+\.\d+$/.test(VERSION) }
   ];
@@ -3609,6 +3619,7 @@ function commandsCmd(root) {
       { cmd: 'agents list|check|quota|dispatch|multi', desc: '외부 AI CLI 오케스트레이션 (dispatch --role 모델 라우팅 1.9.270)' },
       { cmd: 'roles list|set|unset|catalog|suggest|verify', desc: '모델별 역할 부여 (코딩/검수/지휘/디자인/디버그/설계/분배) — 1.9.270' },
       { cmd: 'capabilities [--json]', desc: '권한·보안 표면 공개 (무엇을 하는지 + opt-out + 주의 명령) — 1.9.272' },
+      { cmd: 'state show|start|record|verify|handoff', desc: '.leerness/ JSON 상태 substrate (에이전트 간 인수인계 표준) — 1.9.278' },
       { cmd: 'release channel [--json]', desc: '릴리스 채널 정책 (latest 안정 / next 실험 / 버전 고정) — 1.9.275' },
       { cmd: 'slash-commands [agent] [--json --record --detect --refresh]', desc: 'CLI 에이전트 슬래시 명령 레지스트리 + --help probe 자동 갱신 (1.9.265~267, UR-0021)' },
       { cmd: 'review-request "<request>"', desc: '사용자 요청 사전 검토 (1.9.176)' },
@@ -9464,6 +9475,10 @@ const _LEERNESS_NONSECRET_KEYS = new Set([
   'LEERNESS_ENABLE_CODEX',
   'LEERNESS_ENABLE_AGY',
   'LEERNESS_ENABLE_GROK',
+  'LEERNESS_ENABLE_OPENCODE',
+  'LEERNESS_ENABLE_QWEN',
+  'LEERNESS_ENABLE_AIDER',
+  'LEERNESS_ENABLE_GOOSE',
   'LEERNESS_ENABLE_COPILOT',
   'LEERNESS_ENABLE_OLLAMA',
   'LEERNESS_SKILL_DISCOVER_URL', // 공개 URL
@@ -10122,6 +10137,15 @@ const EXTERNAL_AGENTS = [
   //   → provider cycle / setup-agents / dispatch / slash-commands --refresh probe 가 grok 도 자동 처리.
   { id: 'grok',    bin: 'grok',    envFlag: 'LEERNESS_ENABLE_GROK',    versionArgs: ['--version'], desc: 'xAI Grok CLI (커뮤니티 grok-cli, /model grok-beta 등)',
     installCmd: 'npm i -g @vibe-kit/grok-cli', installHint: 'https://github.com/superagent-ai/grok-cli (xAI API 키 필요 — /login 또는 GROK_API_KEY)' },
+  // 1.9.277 (사용자 명시): 신규 CLI 에이전트 4종 — opencode/qwen/aider/goose. 활성 시 sub-agent dispatch/roles 라우팅 대상.
+  { id: 'opencode', bin: 'opencode', envFlag: 'LEERNESS_ENABLE_OPENCODE', versionArgs: ['--version'], desc: 'opencode — 오픈소스 터미널 AI 코딩 에이전트 (provider-agnostic)',
+    installCmd: 'npm i -g opencode-ai', installHint: 'https://opencode.ai (또는 curl -fsSL https://opencode.ai/install | bash)' },
+  { id: 'qwen',    bin: 'qwen',    envFlag: 'LEERNESS_ENABLE_QWEN',    versionArgs: ['--version'], desc: 'Qwen Code CLI (Alibaba qwen3-coder 등)',
+    installCmd: 'npm i -g @qwen-code/qwen-code', installHint: 'https://github.com/QwenLM/qwen-code (DASHSCOPE/OpenAI 호환 키)' },
+  { id: 'aider',   bin: 'aider',   envFlag: 'LEERNESS_ENABLE_AIDER',   versionArgs: ['--version'], desc: 'Aider — git-aware 페어 프로그래밍 CLI (--model 임의 지정)',
+    installCmd: 'python -m pip install aider-install && aider-install', installHint: 'https://aider.chat (pip install aider-chat · API 키 env)' },
+  { id: 'goose',   bin: 'goose',   envFlag: 'LEERNESS_ENABLE_GOOSE',   versionArgs: ['--version'], desc: 'Goose — Block 오픈소스 범용 로컬 AI 에이전트 (MCP 확장)',
+    installCmd: 'curl -fsSL https://github.com/block/goose/releases/latest/download/download_cli.sh | bash', installHint: 'https://block.github.io/goose (goose configure 로 provider/model 설정)' },
   { id: 'copilot', bin: 'gh',      envFlag: 'LEERNESS_ENABLE_COPILOT', versionArgs: ['copilot', '--version'], desc: 'GitHub Copilot CLI (gh copilot)',
     installCmd: 'gh extension install github/gh-copilot', installHint: 'https://github.com/github/gh-copilot (gh CLI 선행 설치 필요)' },
   // 1.9.146: Ollama 추가 (사용자 명시 요청 #3) — 로컬 LLM, HTTP API 11434
@@ -10200,6 +10224,40 @@ const AGENT_SLASH_COMMANDS = {
       { cmd: 'explain', desc: '명령 설명 (gh copilot explain "...")' },
       { cmd: 'config', desc: 'gh copilot 설정' }
     ]
+  },
+  // 1.9.277: 신규 4종 슬래시/세션 명령 (best-effort 큐레이션 — 배포판마다 차이 가능, 사용자 override 권장)
+  opencode: {
+    label: 'opencode', asOf: '1.9.277', invoke: 'slash',
+    note: 'TUI 세션 슬래시 — 배포판마다 차이 가능.',
+    commands: [
+      { cmd: '/help', desc: '명령 목록' }, { cmd: '/new', desc: '새 세션' }, { cmd: '/models', desc: '모델 선택' },
+      { cmd: '/init', desc: '프로젝트 컨텍스트' }, { cmd: '/undo', desc: '되돌리기' }, { cmd: '/share', desc: '세션 공유' }, { cmd: '/exit', desc: '종료' }
+    ]
+  },
+  qwen: {
+    label: 'Qwen Code CLI', asOf: '1.9.277', invoke: 'slash',
+    note: 'Gemini CLI 계열 슬래시(qwen-code) 기준 큐레이션.',
+    commands: [
+      { cmd: '/help', desc: '명령 목록' }, { cmd: '/clear', desc: '컨텍스트 초기화' }, { cmd: '/memory', desc: '메모리 관리' },
+      { cmd: '/tools', desc: '도구 목록' }, { cmd: '/model', desc: '모델 전환' }, { cmd: '/quit', desc: '종료' }
+    ]
+  },
+  aider: {
+    label: 'Aider', asOf: '1.9.277', invoke: 'slash',
+    note: 'aider 세션 내 슬래시 명령 (in-chat commands).',
+    commands: [
+      { cmd: '/add', desc: '파일 컨텍스트 추가' }, { cmd: '/drop', desc: '파일 제거' }, { cmd: '/ask', desc: '코드 수정 없이 질문' },
+      { cmd: '/run', desc: '셸 명령 실행' }, { cmd: '/test', desc: '테스트 실행' }, { cmd: '/diff', desc: '변경 diff' },
+      { cmd: '/commit', desc: '커밋' }, { cmd: '/undo', desc: '마지막 커밋 취소' }, { cmd: '/help', desc: '도움말' }
+    ]
+  },
+  goose: {
+    label: 'Goose (Block)', asOf: '1.9.277', invoke: 'slash',
+    note: 'goose 세션 내 명령 (배포판마다 차이 가능).',
+    commands: [
+      { cmd: '/?', desc: '도움말' }, { cmd: '/mode', desc: '모드 전환(auto/approve/chat)' }, { cmd: '/extension', desc: 'MCP 확장 관리' },
+      { cmd: '/builtin', desc: '빌트인 확장' }, { cmd: '/exit', desc: '종료' }
+    ]
   }
 };
 function _agentSlashFile(root) { return path.join(absRoot(root), '.harness', 'agent-slash-commands.json'); }
@@ -10411,7 +10469,7 @@ function slashCommandsCmd(root, agentArg, opts = {}) {
 }
 
 // 1.9.157: Provider Registry — 사용자 정의 provider 동적 추가 (.harness/providers.json)
-//   빌트인 6종 (EXTERNAL_AGENTS: claude/codex/agy/grok/copilot/ollama) + 사용자 정의를 merge. OpenRouter / Bedrock 등 새 CLI 즉시 흡수 가능.
+//   빌트인 10종 (EXTERNAL_AGENTS: claude/codex/agy/grok/opencode/qwen/aider/goose/copilot/ollama) + 사용자 정의를 merge. OpenRouter / Bedrock 등 새 CLI 즉시 흡수 가능.
 //   파일 형식: { "schemaVersion": 1, "providers": [{ id, bin, envFlag, versionArgs, desc, installHint }] }
 function _providersFile(root) { return path.join(absRoot(root), '.harness', 'providers.json'); }
 function _readUserProviders(root) {
@@ -11291,6 +11349,11 @@ function _dispatchCommand(agentId, task, writeMode, model) {
   if (agentId === 'codex')  return `codex ${writeMode ? 'exec --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox' : 'exec --skip-git-repo-check'}${m ? ` -m ${m}` : ''} "${q}"`;
   if (agentId === 'agy') return `agy ${writeMode ? '-p --yolo' : '-p'}${m ? ` --model ${m}` : ''} "${q}"`;
   if (agentId === 'grok') return `grok${writeMode ? ' --yolo' : ''}${m ? ` --model ${m}` : ''} "${q}"`;
+  // 1.9.277: 신규 provider 4종 — best-effort 비대화형 호출 (실제 실행은 사용자/메인)
+  if (agentId === 'opencode') return `opencode run${m ? ` --model ${m}` : ''} "${q}"`;
+  if (agentId === 'qwen') return `qwen -p "${q}"${m ? `  # --model ${m} (env/설정)` : ''}`;
+  if (agentId === 'aider') return `aider --message "${q}"${writeMode ? ' --yes' : ' --no-auto-commits'}${m ? ` --model ${m}` : ''}`;
+  if (agentId === 'goose') return `goose run -t "${q}"${m && m !== 'default' ? `  # provider/model: goose configure` : ''}`;
   if (agentId === 'copilot') return `gh copilot suggest "${q}"`;
   if (agentId === 'ollama') return `# ollama — leerness agent "${q}" --provider ollama${m ? ` --model ${m}` : ''} 로 직접 호출 (REPL: leerness agent)`;
   return `# ${agentId}: 명령 빌더 미정의`;
@@ -17678,6 +17741,29 @@ const _PROVIDER_MODEL_CATALOG = {
     { id: 'grok-2', note: 'xAI Grok 2' },
     { id: 'grok-2-mini', note: '빠른 응답' }
   ],
+  // 1.9.277: 신규 provider 4종 모델 (provider-agnostic 인 도구는 default + 설정 안내)
+  opencode: [
+    { id: 'default', note: 'opencode 설정 모델 (opencode auth/models 로 provider별 지정)' },
+    { id: 'anthropic/claude-sonnet', note: 'Anthropic 경유' },
+    { id: 'openai/gpt-5', note: 'OpenAI 경유' }
+  ],
+  qwen: [
+    { id: 'qwen3-coder-plus', note: '코드 특화 최신' },
+    { id: 'qwen-max', note: '최고 성능' },
+    { id: 'qwen-plus', note: '균형' },
+    { id: 'qwen-turbo', note: '빠름' }
+  ],
+  aider: [
+    { id: 'sonnet', note: 'Anthropic Sonnet (aider --model)' },
+    { id: 'gpt-5', note: 'OpenAI' },
+    { id: 'deepseek', note: 'DeepSeek (가성비)' },
+    { id: 'o1-mini', note: '빠른 reasoning' }
+  ],
+  goose: [
+    { id: 'default', note: 'goose configure 로 설정한 provider/model' },
+    { id: 'claude-sonnet', note: 'Anthropic 경유' },
+    { id: 'gpt-5', note: 'OpenAI 경유' }
+  ],
   copilot: [
     { id: 'default', note: 'gh copilot 기본 (모델 선택 불가)' }
   ],
@@ -17690,7 +17776,7 @@ const _PROVIDER_MODEL_CATALOG = {
 };
 
 // 1.9.170: provider cycle 순서 (Tab) — 빌트인 6종(1.9.268 grok 추가). user provider는 동적으로 뒤에 추가.
-const _PROVIDER_CYCLE_ORDER = ['ollama', 'claude', 'codex', 'agy', 'grok', 'copilot'];
+const _PROVIDER_CYCLE_ORDER = ['ollama', 'claude', 'codex', 'agy', 'grok', 'opencode', 'qwen', 'aider', 'goose', 'copilot'];
 
 // 1.9.148: planner/reviewer/actor 역할 시스템 프롬프트 (Gemini 권고 — 자기-승인 편향 방지)
 const _AGENT_ROLE_PROMPTS = {
@@ -17936,6 +18022,144 @@ function capabilitiesCmd(root, opts = {}) {
   log(dm(`  전체 정책: SECURITY.md  ·  기계 판독: leerness capabilities --json`));
 }
 
+// ===== 1.9.278 (UR-0032, GPT-5.5 범용 하네스 방향): .leerness/ JSON 상태 스키마 =====
+//   목적: 마크다운(.harness/)과 병행하는 "구조화 상태 substrate". 에이전트 간 인수인계 표준 —
+//   Claude Code 가 한 작업을 Goose/Codex 가 JSON 으로 정확히 이어받음. 비파괴 (신규 .leerness/ 디렉토리).
+//   향후 UR-0031(MCP verb)/UR-0033(adapter) 가 이 스키마를 공통 호출 표면으로 사용.
+function _leernessStateDir(root) { return path.join(absRoot(root), '.leerness'); }
+// 순수 함수: run 레코드 빌더 (모든 필드 기본값 — GPT-5.5 권고 스키마). startedAt 주입 가능(selftest).
+function _newRunRecord(opts = {}) {
+  return {
+    schemaVersion: 1,
+    run_id: opts.run_id || null,
+    task_id: opts.task_id || null,
+    agent_name: opts.agent_name || null,
+    model_name: opts.model_name || null,
+    started_at: opts.started_at || new Date().toISOString(),
+    ended_at: opts.ended_at || null,
+    goal: opts.goal || '',
+    files_read: Array.isArray(opts.files_read) ? opts.files_read : [],
+    files_changed: Array.isArray(opts.files_changed) ? opts.files_changed : [],
+    commands_run: Array.isArray(opts.commands_run) ? opts.commands_run : [],
+    tests_run: Array.isArray(opts.tests_run) ? opts.tests_run : [],
+    errors: Array.isArray(opts.errors) ? opts.errors : [],
+    decisions: Array.isArray(opts.decisions) ? opts.decisions : [],
+    verification_result: opts.verification_result || null,  // 'pass' | 'fail' | null
+    handoff_summary: opts.handoff_summary || null,
+    status: opts.status || 'in-progress'                    // in-progress | verified | handed-off
+  };
+}
+function _loadLeernessState(root) {
+  const f = path.join(_leernessStateDir(root), 'state.json');
+  if (!exists(f)) return { schemaVersion: 1, project: detectProjectName(root), currentRunId: null, runCounter: 0, updatedAt: null };
+  try { return JSON.parse(read(f)); } catch { return { schemaVersion: 1, project: detectProjectName(root), currentRunId: null, runCounter: 0, updatedAt: null }; }
+}
+function _saveLeernessState(root, state) {
+  const dir = _leernessStateDir(root); mkdirp(dir);
+  state.updatedAt = new Date().toISOString();
+  writeUtf8(path.join(dir, 'state.json'), JSON.stringify(state, null, 2) + '\n');
+}
+function _runFile(root, id) { return path.join(_leernessStateDir(root), 'runs', `${id}.json`); }
+function _loadRun(root, id) { const f = _runFile(root, id); if (!exists(f)) return null; try { return JSON.parse(read(f)); } catch { return null; } }
+function _saveRun(root, rec) { const f = _runFile(root, rec.run_id); mkdirp(path.dirname(f)); writeUtf8(f, JSON.stringify(rec, null, 2) + '\n'); }
+function _splitList(v) { return String(v || '').split(',').map(s => s.trim()).filter(Boolean); }
+
+// leerness state <show|start|record|verify|handoff>
+function stateCmd(root, sub, ...args) {
+  root = absRoot(root || process.cwd());
+  const json = has('--json');
+  sub = sub || 'show';
+
+  if (sub === 'start') {
+    const goal = (args.find(a => a && !a.startsWith('-')) || arg('--goal', '')).trim();
+    const state = _loadLeernessState(root);
+    state.runCounter = (state.runCounter || 0) + 1;
+    const run_id = `run-${String(state.runCounter).padStart(4, '0')}`;
+    const rec = _newRunRecord({
+      run_id, goal,
+      task_id: arg('--task', null),
+      agent_name: arg('--agent', null),
+      model_name: arg('--model', null)
+    });
+    _saveRun(root, rec);
+    state.currentRunId = run_id;
+    _saveLeernessState(root, state);
+    if (json) { log(JSON.stringify({ started: run_id, run: rec }, null, 2)); return; }
+    ok(`run 시작: ${run_id}${rec.agent_name ? ' · agent=' + rec.agent_name : ''}${rec.model_name ? ' · model=' + rec.model_name : ''}`);
+    if (goal) log(`  goal: ${goal}`);
+    log(`  → 기록: leerness state record --files-changed "a,b" --commands "npm test" --decision "..."`);
+    return;
+  }
+
+  const state = _loadLeernessState(root);
+  const curId = state.currentRunId;
+  if ((sub === 'record' || sub === 'verify' || sub === 'handoff') && !curId) {
+    return fail('진행 중 run 없음 — 먼저 leerness state start "<goal>"');
+  }
+
+  if (sub === 'record') {
+    const rec = _loadRun(root, curId); if (!rec) return fail(`run 없음: ${curId}`);
+    for (const [flag, key] of [['--files-read', 'files_read'], ['--files-changed', 'files_changed'], ['--commands', 'commands_run'], ['--tests', 'tests_run'], ['--errors', 'errors'], ['--decision', 'decisions']]) {
+      const v = arg(flag, null); if (v) rec[key] = Array.from(new Set([...(rec[key] || []), ..._splitList(v)]));
+    }
+    _saveRun(root, rec);
+    if (json) { log(JSON.stringify({ recorded: curId, run: rec }, null, 2)); return; }
+    ok(`기록: ${curId} (files_changed ${rec.files_changed.length} · commands ${rec.commands_run.length} · tests ${rec.tests_run.length} · decisions ${rec.decisions.length})`);
+    return;
+  }
+
+  if (sub === 'verify') {
+    const rec = _loadRun(root, curId); if (!rec) return fail(`run 없음: ${curId}`);
+    const result = (arg('--result', '') || (args.find(a => a && !a.startsWith('-')) || '')).toLowerCase();
+    if (result !== 'pass' && result !== 'fail') return fail('--result pass|fail 필요');
+    rec.verification_result = result;
+    rec.status = result === 'pass' ? 'verified' : 'in-progress';
+    const note = arg('--note', null); if (note) rec.decisions = [...(rec.decisions || []), `verify(${result}): ${note}`];
+    _saveRun(root, rec);
+    if (json) { log(JSON.stringify({ verified: curId, result, run: rec }, null, 2)); return; }
+    (result === 'pass' ? ok : warn)(`검증 결과: ${curId} → ${result}`);
+    return;
+  }
+
+  if (sub === 'handoff') {
+    const rec = _loadRun(root, curId); if (!rec) return fail(`run 없음: ${curId}`);
+    const summary = (args.find(a => a && !a.startsWith('-')) || arg('--summary', '')).trim();
+    rec.handoff_summary = summary || rec.handoff_summary || '(요약 없음)';
+    rec.ended_at = new Date().toISOString();
+    rec.status = 'handed-off';
+    _saveRun(root, rec);
+    // 다음 에이전트가 읽을 latest handoff (json + md)
+    const hdir = path.join(_leernessStateDir(root), 'handoff'); mkdirp(hdir);
+    writeUtf8(path.join(hdir, 'latest.json'), JSON.stringify(rec, null, 2) + '\n');
+    writeUtf8(path.join(hdir, 'latest.md'),
+      `# Handoff — ${rec.run_id}\n\n- task: ${rec.task_id || '-'}\n- agent: ${rec.agent_name || '-'} · model: ${rec.model_name || '-'}\n- goal: ${rec.goal || '-'}\n- files_changed: ${rec.files_changed.join(', ') || '-'}\n- tests_run: ${rec.tests_run.join(', ') || '-'}\n- verification: ${rec.verification_result || '-'}\n\n## Summary\n${rec.handoff_summary}\n`);
+    state.currentRunId = null;  // 다음 에이전트가 새 run 시작
+    _saveLeernessState(root, state);
+    if (json) { log(JSON.stringify({ handoff: rec.run_id, run: rec }, null, 2)); return; }
+    ok(`handoff 작성: ${rec.run_id} → .leerness/handoff/latest.{md,json}`);
+    return;
+  }
+
+  // default: show
+  const rec = curId ? _loadRun(root, curId) : null;
+  if (json) { log(JSON.stringify({ state, currentRun: rec }, null, 2)); return; }
+  log(`# leerness state (1.9.278, UR-0032) — .leerness/ 구조화 상태`);
+  log(`project: ${state.project} · runs 누적: ${state.runCounter || 0} · 현재 run: ${curId || '(없음)'}`);
+  if (rec) {
+    log('');
+    log(`## ${rec.run_id} [${rec.status}]`);
+    log(`  goal: ${rec.goal || '-'}`);
+    log(`  agent/model: ${rec.agent_name || '-'} / ${rec.model_name || '-'}`);
+    log(`  files_changed: ${rec.files_changed.join(', ') || '-'}`);
+    log(`  commands_run: ${rec.commands_run.join(', ') || '-'}`);
+    log(`  tests_run: ${rec.tests_run.join(', ') || '-'} · verification: ${rec.verification_result || '-'}`);
+    if (rec.decisions.length) log(`  decisions: ${rec.decisions.length}`);
+  } else {
+    log(`  → 시작: leerness state start "<goal>" [--agent claude --model claude-opus-4-7 --task T-0001]`);
+  }
+  return;
+}
+
 // 1.9.149+1.9.153: REPL 모드 — leerness 자율 AI 에이전트 (multi-provider 세션)
 async function _agentRepl(root, opts) {
   // 1.9.153: .env 자동 로드 (REPL 진입 직전) — install 직후 LEERNESS_ENABLE_* 즉시 반영
@@ -20862,6 +21086,8 @@ async function main() {
   if (cmd === 'roles' || cmd === 'role')             return rolesCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));
   // 1.9.272: leerness capabilities — 권한/보안 표면 공개 (GPT-5.5 외부 리뷰 반영)
   if (cmd === 'capabilities' || cmd === 'security-surface') return capabilitiesCmd(arg('--path', process.cwd()), { json: has('--json') });
+  // 1.9.278 (UR-0032): leerness state <show|start|record|verify|handoff> — .leerness/ 구조화 상태 substrate
+  if (cmd === 'state')                              return stateCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));
   // 1.9.245: API skill cache — 공식 문서·관련링크 자동 정리 (사용자 명시 UR-0015)
   if (cmd === 'api-skill')                           return apiSkillCmd(arg('--path', process.cwd()), args[1] || 'help');
   // 1.9.208: leerness constraints <list|check|add> — 플랫폼/API 제약 사전 체크 (사용자 명시)
@@ -21042,5 +21268,7 @@ module.exports = {
   // 1.9.275: 릴리스 채널 (npm dist-tag, GPT-5.5 리뷰) — 단위 테스트
   _resolveNpmTag, releaseChannelCmd,
   // 1.9.276: init --minimal 파일 필터 (GPT-5.5 2차 리뷰) — 단위 테스트
-  MINIMAL_SKIP_KEYS, coreFiles
+  MINIMAL_SKIP_KEYS, coreFiles,
+  // 1.9.278: .leerness/ 상태 스키마 (UR-0032, GPT-5.5 범용 하네스) — 단위 테스트
+  _newRunRecord, _leernessStateDir, _loadLeernessState, _saveLeernessState, _loadRun, _saveRun, stateCmd
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.9.276",
+  "version": "1.9.278",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -807,14 +807,16 @@ total++;
     && /\| grok \|/.test(r1.stdout)
     && /\| copilot \|/.test(r1.stdout);
   // env 모두 0 → 비활성
-  // 1.9.146: Ollama 추가 → 5 CLI · 1.9.268: grok 정식 승격 → 6 CLI
-  const env2 = { ...process.env, LEERNESS_ENABLE_CLAUDE: '0', LEERNESS_ENABLE_CODEX: '0', LEERNESS_ENABLE_AGY: '0', LEERNESS_ENABLE_GROK: '0', LEERNESS_ENABLE_COPILOT: '0', LEERNESS_ENABLE_OLLAMA: '0' };
+  // 1.9.146: Ollama → 5 · 1.9.268: grok → 6 · 1.9.277: opencode/qwen/aider/goose → 10 CLI
+  const offAll = { LEERNESS_ENABLE_CLAUDE: '0', LEERNESS_ENABLE_CODEX: '0', LEERNESS_ENABLE_AGY: '0', LEERNESS_ENABLE_GROK: '0', LEERNESS_ENABLE_OPENCODE: '0', LEERNESS_ENABLE_QWEN: '0', LEERNESS_ENABLE_AIDER: '0', LEERNESS_ENABLE_GOOSE: '0', LEERNESS_ENABLE_COPILOT: '0', LEERNESS_ENABLE_OLLAMA: '0' };
+  const env2 = { ...process.env, ...offAll };
   const r2 = cp.spawnSync(process.execPath, [CLI, 'agents', 'list', '--json'], { encoding: 'utf8', timeout: 15000, env: env2 });
   let parsed = null;
   try { parsed = JSON.parse(r2.stdout); } catch {}
-  const okJson = parsed && Array.isArray(parsed.agents) && parsed.agents.length === 6 && parsed.agents.every(a => a.status !== 'ready');
-  const ok = okList && okJson;
-  console.log(ok ? '✓ B(1.9.30+1.9.268) agents list: 6 CLI 정의 (claude/codex/agy/grok/copilot/ollama)' : `✗ agents list 실패 (list=${okList} json=${okJson})`);
+  const okJson = parsed && Array.isArray(parsed.agents) && parsed.agents.length === 10 && parsed.agents.every(a => a.status !== 'ready');
+  const okNew = /\| opencode \|/.test(r1.stdout) && /\| qwen \|/.test(r1.stdout) && /\| aider \|/.test(r1.stdout) && /\| goose \|/.test(r1.stdout);
+  const ok = okList && okJson && okNew;
+  console.log(ok ? '✓ B(1.9.30+1.9.277) agents list: 10 CLI (claude/codex/agy/grok/opencode/qwen/aider/goose/copilot/ollama)' : `✗ agents list 실패 (list=${okList} json=${okJson} new=${okNew})`);
   if (!ok) { failed++; console.log(r1.stdout.slice(0, 500)); }
 }
 
@@ -853,11 +855,11 @@ total++;
   const r2 = cp.spawnSync(process.execPath, [CLI, 'agents', 'quota', '--json'], { encoding: 'utf8', timeout: 15000, env });
   let parsed = null;
   try { parsed = JSON.parse(r2.stdout); } catch {}
-  // 1.9.146: Ollama 추가 → 5 CLI · 1.9.268: grok 정식 승격 → 6 CLI
-  const okJson = parsed && Array.isArray(parsed.quota) && parsed.quota.length === 6
+  // 1.9.277: opencode/qwen/aider/goose → 10 CLI
+  const okJson = parsed && Array.isArray(parsed.quota) && parsed.quota.length === 10
     && parsed.quota.every(q => typeof q.id === 'string' && typeof q.status === 'string' && (q.hint === null || typeof q.hint === 'string'));
   const ok = okText && okJson;
-  console.log(ok ? '✓ B(1.9.31+1.9.268) agents quota: 6 CLI 사용량/안내' : `✗ quota 실패 (text=${okText} json=${okJson})`);
+  console.log(ok ? '✓ B(1.9.31+1.9.277) agents quota: 10 CLI 사용량/안내' : `✗ quota 실패 (text=${okText} json=${okJson})`);
   if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
 }
 
@@ -2841,5 +2843,37 @@ total++;
   if (!ok) { failed++; console.log((rVerify.stdout || '').slice(0, 300)); }
 }
 
+// 1.9.278 회귀 (UR-0032): .leerness/ 상태 스키마 라이프사이클 (start→record→verify→handoff→show)
+total++;
+{
+  const sDir = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-state-'));
+  const run = (a) => cp.spawnSync(process.execPath, [CLI, 'state', ...a, '--path', sDir], { encoding: 'utf8', timeout: 15000 });
+  run(['start', 'API 구현', '--agent', 'claude', '--model', 'claude-opus-4-7', '--task', 'T-0001']);
+  run(['record', '--files-changed', 'src/api.js,src/db.js', '--commands', 'npm test', '--tests', '12 passed', '--decision', 'retry 3']);
+  run(['verify', '--result', 'pass']);
+  run(['handoff', 'API 완료, db 마이그레이션은 다음 에이전트']);
+  // 다음 에이전트가 JSON 으로 인수
+  const rShow = run(['show', '--json']);
+  let recOk = false, handoffOk = false;
+  try {
+    const j = JSON.parse(rShow.stdout);
+    // handoff 후 currentRun 은 null, 누적 runs=1
+    recOk = j.state && j.state.runCounter === 1 && j.state.currentRunId === null;
+  } catch {}
+  const runFile = path.join(sDir, '.leerness', 'runs', 'run-0001.json');
+  const hJson = path.join(sDir, '.leerness', 'handoff', 'latest.json');
+  try {
+    const rec = JSON.parse(fs.readFileSync(runFile, 'utf8'));
+    const hf = JSON.parse(fs.readFileSync(hJson, 'utf8'));
+    handoffOk = rec.status === 'handed-off' && rec.verification_result === 'pass'
+      && rec.files_changed.length === 2 && rec.model_name === 'claude-opus-4-7'
+      && rec.task_id === 'T-0001' && hf.handoff_summary && hf.run_id === 'run-0001'
+      && fs.existsSync(path.join(sDir, '.leerness', 'handoff', 'latest.md'));
+  } catch {}
+  const ok = recOk && handoffOk;
+  console.log(ok ? '✓ B(1.9.278) state substrate: start→record→verify→handoff→show (.leerness JSON 인수인계)' : `✗ state 실패 (show=${recOk} handoff=${handoffOk})`);
+  if (!ok) { failed++; console.log((rShow.stdout || '').slice(0, 300)); }
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed`);
 if (failed > 0) process.exit(1);