@ps-neko/nekowork 0.1.0-alpha.11 → 0.1.0-alpha.12

package/AGENTS.md

@@ -28,7 +28,7 @@ fact_forcing: true|false  # PreToolUse 사실 조사 강제 여부
 - `commands/` 는 legacy slash-entry 호환 표면이다. 신규 추가 금지, 점진 마이그레이션.
 - `agents/` 는 페르소나 카탈로그다. 워크플로우는 `skills/` 에서 정의하고 에이전트는 `skills/` 가 호출한다.
 
-## 7단계 풀사이클 (claude-led-codex-review)
+## 7단계 풀사이클 (nekowork-full-cycle)
 
 | 단계 | 담당 | 입력 | 출력 |
 |---|---|---|---|

package/CLAUDE.md

@@ -8,13 +8,13 @@
 
 ## 자동 갱신 영역
 
-<!-- HARNESS:START version=0.1.0-alpha.11 -->
+<!-- HARNESS:START version=0.1.0-alpha.12 -->
 <!-- 이 영역은 scripts/sync-claude-md.js 가 자동 갱신한다. 직접 편집 금지. -->
 
 ## 카탈로그 요약
 
 - agents: 11
-- skills: 10
+- skills: 11
 - commands: 1 (legacy compat)
 - hooks: 5 (gateguard-fact-force, config-protection, quality-gate, pre-bash-dispatcher, persistent-mode)
 - packs: core, builder, productivity, team, debugging, maintenance, pr, catalog-plus, quality, security, frontend, testing, release, enterprise
@@ -93,7 +93,7 @@ nekowork costs --since=7d                   # 비용 추정
 
 ## 매직 키워드 → 스킬 (명시 옵트인만)
 
-자동 활성 키워드 감지는 **사용**하지 않는다. 사용자 룰("확인 후 실행") 우선. 모든 스킬은 슬래시 명령(`/claude-led-codex-review`) 또는 CLI(`nekowork review`) 로 명시 호출.
+자동 활성 키워드 감지는 **사용**하지 않는다. 사용자 룰("확인 후 실행") 우선. 모든 스킬은 슬래시 명령(`/nekowork-full-cycle`) 또는 CLI(`nekowork review`) 로 명시 호출.
 
 ## 핸드오프 5필드
 

package/README.ko.md

@@ -12,7 +12,7 @@ NEKOWORK 는 AI 가 생성한 코드를 위한 로컬 검증 게이트입니다.
 
 여기서 "검증됨"은 정답을 수학적으로 보증한다는 뜻이 아닙니다. verdict 는 결정적 룰과 검증 결과만 결정합니다. 선택적 Codex 리뷰는 advisor 노트로만 기록되며 verdict 에 영향을 주지 않습니다.
 
-> 1.0 scope 와 로드맵: [docs/SCOPE-1.0.md](docs/SCOPE-1.0.md). 장기 비전 (검증 우선 AI 개발 OS): [docs/VISION.md](docs/VISION.md).
+> 1.0 scope 와 로드맵: [docs/SCOPE-1.0.md](docs/SCOPE-1.0.md). 장기 비전 (검증 우선 AI 개발 공장): [docs/VISION.md](docs/VISION.md).
 
 ## 용어
 
@@ -189,10 +189,10 @@ NEKOWORK는 하나의 거대한 agent 묶음이 아니라, 일을 나누고 검
 ## 현재 alpha 상태
 
 - Package: `@ps-neko/nekowork`
-- Current alpha: `0.1.0-alpha.10` (npm `@alpha` published 2026-05-14)
+- Current alpha: `0.1.0-alpha.11` (npm `@alpha` published 2026-05-16)
 - CLI: `nekowork`
 - Legacy/internal alias: `harness`
-- Tests: 401 pass
+- Tests: 501 pass
 - npm audit: 0 moderate+ issues
 - Fresh `npx @alpha` smoke: pass
 

package/README.md

@@ -6,11 +6,19 @@
 
 [![validate](https://github.com/Ps-Neko/NEKOWORK/actions/workflows/harness-validate.yml/badge.svg)](https://github.com/Ps-Neko/NEKOWORK/actions/workflows/harness-validate.yml)
 
+<p align="center">
+  <a href="https://ps-neko.github.io/NEKOWORK/?fixture=sample-pr-001">
+    <img src="docs/assets/hero.gif" alt="NEKOWORK Verification Factory — Claude advisor 가 LGTM 한 코드를 NEKOWORK 결정적 규칙이 BLOCK 하는 12-station 시연" width="800" />
+  </a>
+  <br/>
+  <em>Claude said LGTM. NEKOWORK blocked.</em> &nbsp;·&nbsp; <a href="https://ps-neko.github.io/NEKOWORK/?fixture=sample-pr-001"><strong>Live demo →</strong></a>
+</p>
+
 NEKOWORK is a local verification gate for AI-generated code. It analyzes the diff, runs deterministic risk rules, collects evidence, and decides whether the change is safe to merge or apply — without auto-committing, auto-pushing, or trusting LLM verdicts.
 
 Note: "Verified" means independently reviewed with recorded evidence — not mathematically proven correct. The verdict is decided by deterministic rules and check results. Optional Codex review is recorded as an advisor note only and never controls the verdict.
 
-> 1.0 scope and roadmap: [docs/SCOPE-1.0.md](docs/SCOPE-1.0.md). Long-term vision (Verification-first AI development OS): [docs/VISION.md](docs/VISION.md).
+> 1.0 scope and roadmap: [docs/SCOPE-1.0.md](docs/SCOPE-1.0.md). Long-term vision (Verification-first AI development factory): [docs/VISION.md](docs/VISION.md).
 
 Note: "ship" in NEKOWORK is a **readiness decision** (`SHIP_READY` or `NO_SHIP`), not a deployment. The `ship` step decides whether `apply` is allowed; it never commits, pushes, deploys, or publishes by itself.
 
@@ -199,9 +207,9 @@ For comparison and positioning: [docs/WHY-NEKOWORK.md](docs/WHY-NEKOWORK.md).
 
 ## Status
 
-Current repository version: `0.1.0-alpha.11` · Current npm alpha: `@ps-neko/nekowork@0.1.0-alpha.10` (published 2026-05-14, `@alpha` dist-tag). Package: `@ps-neko/nekowork`. CLI: `nekowork` (`harness` is a legacy alias). Default: mock providers, no API keys.
+Current repository version: `0.1.0-alpha.12` · Current npm alpha: `@ps-neko/nekowork@0.1.0-alpha.11` (published 2026-05-16, `@alpha` dist-tag). Package: `@ps-neko/nekowork`. CLI: `nekowork` (`harness` is a legacy alias). Default: mock providers, no API keys.
 
-Verification: `npm run lint` pass · `npm test` 401 tests pass · `npm audit --audit-level=moderate` 0 vulns · `npm pack --dry-run --json` pass · `npx -y @ps-neko/nekowork@alpha check` pass with warnings only.
+Verification: `npm run lint` pass · `npm test` 501 tests pass · `npm audit --audit-level=moderate` 0 vulns · `npm pack --dry-run --json` pass · `npx -y @ps-neko/nekowork@alpha check` pass with warnings only.
 
 Live provider auth delegates to local CLI sessions (`claude auth status`, `codex login`, `gemini`); long-lived API key env vars (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, `GOOGLE_API_KEY`) are blocked unless `HARNESS_AUTH_ALLOW_ENV_OVERRIDE=1`. See [docs/SETUP.md](docs/SETUP.md).
 

package/WORKING-CONTEXT.md

@@ -10,7 +10,7 @@
 ## Current Truth
 
 - 위치: `C:/Users/Mun/harness/` · 브랜치: `main`
-- 버전: `0.1.0-alpha.11` (repo candidate, npm alpha = 0.1.0-alpha.10)
+- 버전: `0.1.0-alpha.12` (repo; npm alpha 는 `0.1.0-alpha.11` published 2026-05-16, alpha.12 publish 진행 중)
 - 카탈로그: 11 agents · 5 skills (+1 ralph) · 5 hooks · 6 modules · 5 profiles
 - 5 빌더 모두 동작 (claude / codex / cursor / gemini / opencode) + codemaps
 - `npm test`, `npm run lint`, `npm audit --audit-level=moderate`, provider live smoke, Rust release build 검증 경로 유지
@@ -26,14 +26,21 @@
 ## Active Queues
 
 ### In Progress
-- 2.5시간 잡티 제거 배치 (CHANGELOG / WORKING-CONTEXT / Validator 경고 / RUNBOOK·PORTING / Security Bar)
+- 외부 알파 5명 모집 + 7일 피드백 수집 (POST-RELEASE-CHECKLIST §4-§5, **사용자 수동 social work**)
 
 ### Next
-- AUDIT 잔존: npm publish 결정, 사내 PoC 결합, OIDC/dead-man/supply-chain 심화
+- 1.0 게이트 5조건 점검 (SCOPE-1.0 §13.2): recall ≥ 0.90, FP ≤ 0.10 (real-world corpus), 외부 알파 3/5 "다시 쓰겠다", CRITICAL 미탐 0, 치명적 오탐 0
+- real-world fixture 추가 후 `npm run bench:rules` 재측정
+- 코드 품질 핫스팟 3건 (cli.js 분해 / orchestrator 보일러플레이트 추출 / 미사용 export) — **publish 게이트 통과 이후**
+
+### 절대 금지 (현 단계)
+- 코드 추가 (외부 피드백 없이 추측으로 룰 늘리기 금지)
+- scope 확장 (verify-skill / verify-release 등은 1.x)
+- "1.0 곧 출시" 류 마케팅
 
 ## Open PR Classification
 
-(없음 — 레포 미 push)
+(이전 작업 — auth migration / harness.dev placeholder / 검증 게이트 cut 등은 main 머지 완료, 메모리 `nekowork-*` 참조)
 
 ## Interfaces
 
@@ -50,3 +57,6 @@
 - 2026-04-29: P1 회수 세션 완료 (`docs/dev-log/2026-04-29-p1-recovery.md`). 빈 디렉터리 6 → 0, 미구현 스크립트 9 → 0, ARCHITECTURE 528줄, 73 테스트.
 - 2026-04-29: 잡티 제거 배치 진행 중 — 본 파일 갱신 + Validator 경고 정합 + RUNBOOK/PORTING/Security Bar 보완.
 - 2026-04-30: **auth migration 완료**. PR #1-#3 (3계층 인증 + GitHub OAuth + OS keychain) main 머지 (`60e9de9` → `7c4f2c8`, +4 commits, rebase merge). PR #2/#3 은 phase-1 옛 SHA 포함으로 force-push 1회씩(`--onto origin/main bf72841`/`b2b1bce` + `--force-with-lease`). Smoke 3/4 PASS (#1 `claude /status` Claude Max, #2 override 차단 3 케이스, #4 keychain Windows Credential Manager). #3 GitHub OAuth Device Flow 는 OAuth App 미등록으로 사용자 자율 보류 — 실제 GitHub automation 사용 시점에 수행. PR #4 (codex 0.125+ 호환) 는 본 작업과 무관 OPEN 잔존.
+- 2026-05-14: **alpha.10 npm publish 완료**. dist-tag `@alpha`. 19개 CLI 명령 wide surface. 코드 품질 핫스팟 3건 진단 (cli.js 1543 LOC / orchestrator 보일러플레이트 / 미사용 export 3건) — publish 게이트 후 처리.
+- 2026-05-15~16: **1.0 검증 게이트 cut + alpha.11 publish**. `feat(verify-pr)` 5 deterministic rules + Auto-Apply-Commit-Push + GitHub Actions PR comment + bench:rules. 정체성을 "verification-first AI development factory" 12-Station 으로 정제 (VISION.md). README hero 는 검증 게이트 카피 유지.
+- 2026-05-16: **post-publish CI red 사고 복구** (`6a0e862`). `.gitignore *.pem` 룰이 secret-detection 룰 자체 fixture 까지 차단 → alpha.11 가 CI red 6 commit streak 상태로 publish. `!tests/fixtures/**/*.pem` 예외 + synthetic fixture 2개 commit 으로 복구. POST-RELEASE-CHECKLIST §0.2 에 CI green 3항목 게이트 추가 (`f6995ab`). 메모리 `nekowork-alpha11-verify-pr` 의 '자기모순' 섹션 참조.

package/agent.yaml

@@ -1,7 +1,7 @@
 spec_version: gitagent/0.1.0
 name: nekowork
 runtime_name: harness
-version: 0.1.0-alpha.11
+version: 0.1.0-alpha.12
 description: "NEKOWORK - Verified autopilot for AI code changes with Codex verification, Human Gate, and explicit apply"
 license: MIT
 homepage: https://github.com/Ps-Neko/NEKOWORK
@@ -23,7 +23,7 @@ agents:
   - doc-writer
 
 skills:
-  - claude-led-codex-review
+  - nekowork-full-cycle
   - plan-eng-review
   - tdd-workflow
   - acceptance-coverage
@@ -33,10 +33,11 @@ skills:
   - release-readiness
   - porting
   - ralph   # 명시 옵트인 영속 루프. 자동 키워드 활성 OFF.
+  - verified-gate   # strict 검증 게이트 진입점. 명시 옵트인, 자동 키워드 OFF.
 
 commands:
   # legacy compat (slash entry). 신규 추가 금지.
-  - claude-led-codex-review
+  - nekowork-full-cycle
 
 hooks:
   file: hooks/hooks.json
@@ -200,7 +201,7 @@ auth:
     deny_static_api_keys_in_repo: true
 
 routing:
-  # 단계별 routing 표는 skills/claude-led-codex-review/SKILL.md 가 정전(canon).
+  # 단계별 routing 표는 skills/nekowork-full-cycle/SKILL.md 가 정전(canon).
   eco_mode_floor: sonnet
   human_gate_triggers:
     severity: critical

package/agents/codex-challenger.md

@@ -5,7 +5,7 @@ provider: codex
 model: gpt-5-codex
 level: 3
 disallowedTools: [Write, Edit, Bash, Network]
-trigger: ["codex challenge", "--secure", "claude-led-codex-review:6"]
+trigger: ["codex challenge", "--secure", "nekowork-full-cycle:6"]
 hand_off_to: []
 sandbox: read-only
 network_access: false

package/agents/codex-reviewer.md

@@ -5,7 +5,7 @@ provider: codex
 model: gpt-5-codex
 level: 3
 disallowedTools: [Write, Edit, Bash, Network]
-trigger: ["codex review", "claude-led-codex-review:5"]
+trigger: ["codex review", "nekowork-full-cycle:5"]
 hand_off_to: []
 sandbox: read-only
 network_access: false

package/commands/nekowork-full-cycle.md

@@ -0,0 +1,29 @@
+---
+description: "Claude 주도 + Codex 위임 7단계 풀사이클. nekowork-full-cycle 스킬 호출."
+---
+
+# /nekowork-full-cycle
+
+이 슬래시 명령은 `nekowork-full-cycle` 스킬의 legacy compat 진입점이다. 신규 워크플로우는 스킬에서 정의되지만 슬래시 호출 호환성을 위해 보존.
+
+## 동작
+
+`Skill` 도구로 `nekowork-full-cycle` 를 즉시 호출. 인자가 있으면 작업 요약으로 전달, 없으면 사용자에게 한 줄 요약을 요청.
+
+## 인자
+
+- `$ARGUMENTS` — 작업 요약 한 줄
+- `--fast` — 단계 1·6 스킵
+- `--secure` — 단계 6 강제
+- `--no-ship` — 단계 7 생략
+
+## 예시
+
+```
+/nekowork-full-cycle JWT 검증 미들웨어 추가 --secure
+/nekowork-full-cycle 결제 환불 로직 버그 수정
+/nekowork-full-cycle --fast 사소한 리팩토링
+/nekowork-full-cycle 새 API 엔드포인트 --no-ship
+```
+
+전체 명세는 `skills/nekowork-full-cycle/SKILL.md` 참조.

package/docs/ARCHITECTURE.md

@@ -207,8 +207,8 @@ Builders project the catalog into tool-specific files:
 
 ## Release State
 
-The current repository release line is `0.1.0-alpha.10` alpha candidate:
+The current repository release line is `0.1.0-alpha.12`:
 
 - Repository and GitHub tarball release are available.
-- Public npm alpha is published as `@ps-neko/nekowork@alpha` and currently points at `0.1.0-alpha.9` until alpha.10 is published.
+- Public npm alpha is published as `@ps-neko/nekowork@alpha` and currently points at `0.1.0-alpha.11` (published 2026-05-16).
 - Clone, submodule, and local checkout integration remain supported for repository-pinned workflows.

package/docs/CHANGELOG.md

@@ -4,7 +4,16 @@
 
 ## [Unreleased]
 
-## [0.1.0-alpha.11] - TBD
+## [0.1.0-alpha.12] - TBD
+
+### Changed
+- `verify-pr --full-scan` (alias `--full`): scans all tracked files as a synthetic added-diff via the shared `synthesizeFilesAsDiff` helper, so first-time onboarding no longer requires a throwaway repo with a fake diff. (First external-user feedback.)
+- `INSUFFICIENT_EVIDENCE` verdict now explains itself: its reason/summary clarify "not a failure — risk checks passed; add a test command to verify, or use `--ci-exit-soft`," instead of reading like a hard block. Verdict logic is unchanged — an unverified source change still does not auto-pass (SCOPE-1.0 §7).
+
+### Fixed
+- Language detection now finds project markers (`go.mod`, `package.json`, `Cargo.toml`, …) in subdirectories, not just the repo root. A Go project with `go.mod` in a subfolder (e.g. `backend/`) was misdetected as `unknown` and reported `INSUFFICIENT_EVIDENCE` for source changes; it is now detected with its test command available. Root markers still take precedence, and excluded dirs (`node_modules`, `vendor`, build output) are skipped — no behavior change for root-level projects. (First external-user feedback.)
+
+## [0.1.0-alpha.11] - 2026-05-16
 
 ### Added
 - Add `nekowork verify-pr` 1.0 entrypoint: scans diff (working tree / staged / range / patch file) with deterministic risk rules, writes evidence to `.nekowork/evidence/`, decides verdict from rule findings + check availability, renders `REPORT.md`.

package/docs/DEMO.md

@@ -143,7 +143,7 @@ project root : C:\path\to\harness
 
 STATUS  CHECK                   MESSAGE
 PASS    node                    Node 24.x
-PASS    package metadata        @ps-neko/nekowork@0.1.0-alpha.10; public alpha package
+PASS    package metadata        @ps-neko/nekowork@0.1.0-alpha.11; public alpha package
 PASS    git worktree            project root is inside a git worktree
 WARN    gemini cli              installed, auth status is not checked non-interactively
 

package/docs/GUIDED-MODE.md

@@ -31,7 +31,7 @@ Example:
 
 ```text
 +-- NEKOWORK Cockpit -------------------------------------+
-| Version : 0.1.0-alpha.10                                |
+| Version : 0.1.0-alpha.12                                |
 | Project : /path/to/project                              |
 | Git     : dirty (2 changed paths)                       |
 | Provider: mock                                          |

package/docs/PORTING.md

@@ -1,6 +1,6 @@
 # Porting NEKOWORK Into Another Project
 
-NEKOWORK `0.1.0-alpha.11` is the current repository alpha candidate. The published `@ps-neko/nekowork@alpha` package points at `0.1.0-alpha.10` until alpha.11 is published. Use npm alpha for the shortest published install path, or use a submodule/local checkout for repository-pinned workflows and examples.
+NEKOWORK `0.1.0-alpha.12` is the current repository version (npm `@ps-neko/nekowork@alpha` currently published at `0.1.0-alpha.11`, 2026-05-16). Use npm alpha for the shortest published install path, or use a submodule/local checkout for repository-pinned workflows and examples.
 
 ## Local Demo First
 

package/docs/POST-RELEASE-CHECKLIST.md

@@ -6,6 +6,8 @@
 
 ## 0. 사전 확인 (publish 전)
 
+### 0.1 로컬 검증
+
 - [x] git tag `v0.1.0-alpha.11` 로컬 생성 (커밋 `c8f55bd`)
 - [ ] `npm test` 통과 (494/494)
 - [ ] `npm run bench:rules` 5/5 PASS
@@ -13,6 +15,16 @@
 - [ ] `npm audit --audit-level=moderate` 0 vulns
 - [ ] `npm pack --dry-run --json` 정상
 
+### 0.2 CI green 게이트 (publish 차단)
+
+**로컬 PASS ≠ CI PASS.** `.gitignore` / 환경 변수 / fixture 경로 차이로 환경이 갈릴 수 있음. publish 전 다음 3개를 모두 확인:
+
+- [ ] **마지막 1 commit CI 성공** — `gh run list --branch main --limit 1 --json conclusion --jq '.[0].conclusion'` 가 `success`
+- [ ] **최근 5 commit CI 추세** — `gh run list --branch main --limit 5 --json conclusion --jq '[.[] | .conclusion] | join(",")'` 결과에 `failure` 가 1개라도 있으면 publish 금지. red streak 의 근본 원인을 먼저 잡고 다음 commit 으로 green 회복 확인 후 진행
+- [ ] **fixture / `.gitignore` 변경이 있었다면 충돌 검토** — 새 fixture 가 시크릿 룰 (`*.pem` / `*.key` / `*.crt` / `*.p12` / `*.pfx` / `credentials*.json`) 에 차단되지 않는지 `git check-ignore <fixture-path>` 로 확인. 차단되면 `!tests/fixtures/**/<pattern>` 예외 룰 추가
+
+> **2026-05-16 사고 (이 게이트의 도출 근거):** alpha.11 가 **CI red 6 commit streak** 상태에서 publish 됨. 원인: `.gitignore` 의 `*.pem` 룰이 secret-detection 룰 자체의 fixture (`positive/004-private-key.pem`, `negative/005-public-key.pem`) 까지 차단. 로컬 `npm test` 는 fixture 가 존재하므로 PASS, CI 체크아웃은 fixture 가 없어서 FAIL. **NEKOWORK 가 NEKOWORK 자신의 CI 를 깨뜨린 자기모순.** commit `6a0e862` 로 `.gitignore` 예외 + 두 synthetic fixture commit 으로 복구. 위 3개 게이트가 이 사고에서 도출됨. 다음 alpha 에서는 0.1 → 0.2 순서로 검증 후 publish.
+
 ## 1. Publish (사용자 수동)
 
 ```bash
@@ -33,37 +45,42 @@ npx -y @ps-neko/nekowork@alpha --version
 
 ## 2. README 즉시 갱신 (publish 직후 1 commit)
 
-`README.md` 의 Status 섹션 라인 한 줄:
+> ✅ alpha.11 (2026-05-16) 에서 이미 완료. 다음 alpha publish 시 동일 패턴.
 
-```diff
-- Current repository version: `0.1.0-alpha.11` · Current npm alpha: `@ps-neko/nekowork@0.1.0-alpha.10` (published 2026-05-14, `@alpha` dist-tag).
-+ Current repository version: `0.1.0-alpha.11` · Current npm alpha: `@ps-neko/nekowork@0.1.0-alpha.11` (published <YYYY-MM-DD>, `@alpha` dist-tag).
-```
-
-`docs/SETUP.md` 와 `docs/PORTING.md` 의 첫 문단도 같이 갱신:
+publish 직후 update 가 필요한 파일들:
 
-```diff
-- The published `@ps-neko/nekowork@alpha` package points at `0.1.0-alpha.10` until alpha.11 is published.
-+ The published `@ps-neko/nekowork@alpha` package points at `0.1.0-alpha.11`.
-```
-
-`docs/CHANGELOG.md` 의 `[0.1.0-alpha.11] - TBD` → `- YYYY-MM-DD`.
+- `README.md` Status 섹션: `Current npm alpha: ...` 라인 + `npm test N tests pass` 라인
+- `README.ko.md` "현재 alpha 상태" 섹션: Current alpha + Tests 라인
+- `docs/SETUP.md`: 첫 문단 published alpha 핀
+- `docs/PORTING.md`: 첫 문단 published alpha 핀
+- `docs/CHANGELOG.md`: `[0.1.0-alpha.X] - TBD` → `- YYYY-MM-DD`
+- `docs/DEMO.md`: doctor example 의 alpha 버전 라인 (version-consistency.test.js 가 SVG + README 와 교차 검증)
+- `docs/assets/demo-terminal.svg`: package metadata 의 alpha 버전 (version-consistency.test.js 가 README 의 npmAlpha 와 일치 강제)
+- `WORKING-CONTEXT.md`: 버전 라인 ("repo + npm alpha 동기" 표현으로)
+- `tests/unit/version-consistency.test.js`: `Tests: N` assertion 의 N 갱신
 
 ## 3. Smoke test (publish 직후)
 
-새 임시 디렉토리에서:
+새 임시 디렉토리에서. **중요**: 베이스 파일만 먼저 commit 하고, AI 가 만들었을 법한
+위험 변경은 untracked / unstaged 로 남겨야 verify-pr 의 working-tree 모드가
+그 변경을 잡습니다 (diff-parser 가 ls-files --others 로 untracked 도 흡수).
+전부 한 번에 `git add -A` 하면 diff 가 비어서 ALLOW 가 됩니다.
 
 ```bash
-mkdir /tmp/neko-smoke && cd $_ && git init -q && git config user.email t@t && git config user.name t
+TMP=$(mktemp -d) && cd "$TMP"
+git init -q && git config user.email t@t && git config user.name t
+
+# 1. 베이스만 commit (untracked 가 working-tree diff 에 들어가도록)
 echo '{"name":"smoke","scripts":{"test":"echo ok"}}' > package.json
-git add -A && git commit -q -m init
+git add package.json && git commit -q -m init
 
-# 1. AI 가 만들었을 법한 위험 변경
+# 2. AI 가 만들었을 법한 위험 변경 — untracked 로 둠
+mkdir -p src
 cat > src/auth.ts <<'EOF'
 export const k = process.env.API_KEY || "sk-leaked-fallback-test";
 EOF
 
-# 2. verify-pr 실행
+# 3. verify-pr 실행
 npx -y @ps-neko/nekowork@alpha verify-pr
 
 # 3. 기대: verdict BLOCK, exit 2, REPORT.md 와 decision.json 생성

package/docs/SCOPE-1.0.md

@@ -5,7 +5,7 @@
 ## 1. 결정 요약
 
 NEKOWORK 1.0 은 **AI 가 만든 PR/diff 를 머지해도 되는지 판정하는 검증 게이트** 로 포지셔닝한다.
-장기 비전 ("Verification-first AI development OS") 은 `docs/VISION.md` 에만 남기고, 1.0 의 README/CLI hero/마케팅에는 노출하지 않는다.
+장기 비전 ("Verification-first AI development factory") 은 `docs/VISION.md` 에만 남기고, 1.0 의 README/CLI hero/마케팅에는 노출하지 않는다.
 
 알파.10 의 wide surface (19개 명령) 는 **Phased Cut** 으로 좁힌다 — 1.0 에서는 hero 강등만, 실제 breaking 은 2.0.
 

package/docs/SETUP.md

@@ -2,7 +2,7 @@
 
 Start with [QUICKSTART.md](QUICKSTART.md) if this is your first run. This page is the deeper contributor setup guide.
 
-NEKOWORK `0.1.0-alpha.11` is the current repository alpha candidate. The published `@ps-neko/nekowork@alpha` package points at `0.1.0-alpha.10` until alpha.11 is published. Use npm alpha for the shortest first-run path, or use a source checkout, submodule, or local repository integration when you need examples, tests, or repository-pinned workflows.
+NEKOWORK `0.1.0-alpha.12` is the current repository version (npm `@ps-neko/nekowork@alpha` currently published at `0.1.0-alpha.11`, 2026-05-16). Use npm alpha for the shortest first-run path, or use a source checkout, submodule, or local repository integration when you need examples, tests, or repository-pinned workflows.
 
 ## Requirements
 

package/docs/VISION.md

@@ -7,13 +7,19 @@
 ## One-liner
 
 ```text
-Verification-first AI development OS
+Verification-first AI development factory.
+AI builds. NEKOWORK verifies. Humans decide.
+Nothing ships without evidence.
 ```
 
 ```text
-검증 우선 AI 개발 OS
+검증 우선 AI 개발 공장.
+AI 가 만들고, NEKOWORK 가 검증하고, 사람이 결정한다.
+증거 없이는 출고하지 않는다.
 ```
 
+> 비유: NEKOWORK 는 검증관이 붙은 AI 개발 공장. 입력은 아이디어, 출력은 증거가 첨부된 변경. 검사 없이는 출고하지 않는다.
+
 ## 핵심 원칙
 
 NEKOWORK 의 모든 장기 확장은 단 하나의 원칙에 묶입니다.
@@ -28,19 +34,75 @@ AI 생성물은 신뢰하지 않고 검증한다.
 
 이 원칙이 6개 레이어 전체를 묶습니다.
 
-## 6 레이어 모델 (long-term)
+## 12-Station Factory Model (long-term)
+
+> **주의:** 12 patterns ≠ 12 sequential steps. **12 patterns = 공장 운영에 필요한 12개 설계 블록**.
+> 작업 유형에 따라 일부 station 만 거친다. 모든 작업이 12 station 을 순차적으로 도는 것은 아니다.
 
 ```text
-1. Discover  : 무엇을 만들지 묻는다              (ask 의 미래형)
-2. Spec      : 요구사항·수용조건을 쓴다          (plan 의 미래형)
-3. Plan      : 작업을 작게 나눈다                (plan 의 분해 단계)
-4. Build     : AI 가 구현한다                    (외부 AI 의 자리)
-5. Verify    : 테스트·룰·증거 수집·판정           (1.0 의 코어, NEKOWORK 의 칼날)
-6. Decide    : 통과·보류·차단·명시적 적용         (1.0 의 게이트)
+[입고]
+1.  Intake              사용자 요청 접수
+2.  Clarify             제품 질문 / 요구사항 흔들기
+
+[기획]
+3.  Route               작업 유형 분류: bug / feature / refactor / release / docs
+4.  Context             도메인 문서 / 기존 구조 / 제약 확인
+5.  Spec                acceptance criteria 작성
+6.  Plan                실행 계획과 작업 단위 분해
+
+[제조]
+7.  Team                read-only 전문가 handoff 생성
+8.  Work                단일 executor 가 코드 변경
+
+[검사]  ← 1.0 의 칼날
+9.  Self-Review         작성자 1차 검토
+10. Independent Review  Codex / 별도 모델 교차 검토
+
+[출고]
+11. Human Gate / Apply  위험 작업은 사람 승인 후 적용
+
+[학습]
+12. Memory / Evolution  결과·실패·규칙·개선점을 다음 작업에 반영
 ```
 
-NEKOWORK 의 **차별 핵심은 5와 6**.
-1~4는 외부 AI (Claude Code / Codex / Cursor / Gemini / 사람) 가 채울 수 있으며, NEKOWORK 는 그 출력을 **입력 소스로 흡수**합니다.
+NEKOWORK 의 **차별 핵심은 station 9–11** ([검사] + [출고]).
+1–8 은 외부 AI (Claude Code / Codex / Cursor / Gemini / 사람) 가 채울 수 있으며, NEKOWORK 는 그 출력을 **입력 소스로 흡수**합니다.
+station 12 는 검사·출고 결과를 다음 작업에 되먹이는 닫힌 루프 — 1.x 의 rule learning, 2.x 의 자동 룰 제안으로 이어집니다.
+
+### 기존 6-layer 와의 매핑
+
+> 참고용. 2026-05-16 이전 문서가 6-layer (Discover / Spec / Plan / Build / Verify / Decide) 로 작성되어 있음. 12-station 은 그것을 더 정밀하게 분해한 것이며 정체성 변경이 아닙니다.
+
+| 6-layer | 12-station |
+|---|---|
+| 1. Discover | 1 Intake · 2 Clarify |
+| 2. Spec | 3 Route · 4 Context · 5 Spec |
+| 3. Plan | 6 Plan · 7 Team |
+| 4. Build | 8 Work |
+| 5. Verify | 9 Self-Review · 10 Independent Review |
+| 6. Decide | 11 Human Gate / Apply |
+| — | 12 Memory / Evolution (신규) |
+
+### 각 station 의 현재 상태
+
+> alpha.11 기준 (2026-05-16). 자세한 1.0 scope 는 [SCOPE-1.0.md](SCOPE-1.0.md). 이 표는 **약속이 아니라 현재 그림** — CLI 명령 추가는 별도 alpha 결정 사항.
+
+| Station | 1.0 (현재) | 1.x | 2.x |
+|---|---|---|---|
+| 1 Intake | 외부 (사람 / Cursor / Claude Code) | upstream file 자동 수집 확장 | NEKOWORK 진입점 |
+| 2 Clarify | 외부 | — | NEKOWORK 진입점 |
+| 3 Route | 결정적 룰이 diff 에서 자동 추론 | task type label | 진입점 분기 |
+| 4 Context | upstream file (`context.md` / `DOMAIN.md`) 자동 픽업 | — | NEKOWORK 진입점 |
+| 5 Spec | upstream file (`SPEC.md`) 자동 픽업 | acceptance coverage 측정 | NEKOWORK 진입점 |
+| 6 Plan | upstream file (`PLAN.md`) 자동 픽업 | plan 검증 룰 | NEKOWORK 진입점 |
+| 7 Team | read-only handoff (legacy `team`) | — | 검증 게이트 강제 |
+| 8 Work | 외부 executor (Claude Code / Cursor / Codex) | — | 검증 게이트 강제 |
+| **9 Self-Review** | `verify-pr` 결정적 룰 + 증거 수집 | check 자동 실행 (test / lint / typecheck / audit) | check 매트릭스 확장 |
+| **10 Independent Review** | Codex review (advisor 노트, verdict 영향 없음) | `verify-skill` / `verify-release` family | 멀티 reviewer 가중치 |
+| **11 Human Gate / Apply** | `decision.json` + 명시적 `apply` | policy profiles + team approval flow | apply 범위 확장 (patch → workflow) |
+| 12 Memory / Evolution | session evidence + `bench:rules` rule efficacy | rule learning | 자동 룰 제안 |
+
+**진한 station (9 · 10 · 11) 이 NEKOWORK 의 칼날** — 1.0 의 출하 기준은 이 세 station 의 신뢰도입니다.
 
 ## 외부 AI 의 정의
 
@@ -76,9 +138,9 @@ OMC / ECC / Cursor / Claude Code / Codex / Gemini 는 NEKOWORK 의 경쟁자가
 
 단, **모든 위쪽 레이어는 검증 게이트에 묶여야 합니다.** 검증되지 않은 산출물은 다음 단계로 가지 못합니다. 이게 OMC/ECC 식 자유로운 multi-agent runtime 과의 차이입니다.
 
-### 3.x 이후 — Verification-first AI development OS
-- 위 1~6 레이어가 모두 검증으로 묶임
-- 외부 AI 는 입력 소스 또는 어시스턴트로 사용됨
+### 3.x 이후 — Verification-first AI development factory
+- 12 station 이 모두 검증으로 묶임
+- 외부 AI 는 입력 소스 또는 어시스턴트 ("공장 안 작업자 또는 외부 납품원") 로 사용됨
 - 사용자는 "NEKOWORK 안에서 작업하면 절대 검증 없이 머지·apply 되지 않는다" 를 신뢰
 
 ## 무엇이 NEKOWORK 가 아닌가

package/docs/assets/demo-terminal.svg

@@ -25,7 +25,7 @@
     <text x="72" y="147" fill="#d7e3ec">NEKOWORK doctor</text>
     <text x="72" y="179" fill="#8fb3c8">STATUS  CHECK              MESSAGE</text>
     <text x="72" y="211" fill="#9be9a8">PASS    node               Node 22+</text>
-    <text x="72" y="243" fill="#9be9a8">PASS    package metadata   @ps-neko/nekowork@0.1.0-alpha.10</text>
+    <text x="72" y="243" fill="#9be9a8">PASS    package metadata   @ps-neko/nekowork@0.1.0-alpha.11</text>
     <text x="72" y="275" fill="#9be9a8">PASS    api key env        no delegated-provider API key overrides</text>
     <text x="72" y="307" fill="#ffd166">WARN    gemini cli         auth status is not checked non-interactively</text>
     <text x="72" y="339" fill="#d7e3ec">summary: WARN (5 pass, 2 warn, 0 fail)</text>

package/manifests/install-components.json

@@ -106,10 +106,10 @@
       "target": { "claude": ".claude/agents/doc-writer.md" }
     },
 
-    "skill:claude-led-codex-review": {
+    "skill:nekowork-full-cycle": {
       "type": "skill",
-      "source": "skills/claude-led-codex-review/",
-      "target": { "claude": ".claude/skills/claude-led-codex-review/" }
+      "source": "skills/nekowork-full-cycle/",
+      "target": { "claude": ".claude/skills/nekowork-full-cycle/" }
     },
     "skill:plan-eng-review": {
       "type": "skill",
@@ -152,10 +152,10 @@
       "target": { "claude": ".claude/skills/porting/" }
     },
 
-    "command:claude-led-codex-review": {
+    "command:nekowork-full-cycle": {
       "type": "command",
-      "source": "commands/claude-led-codex-review.md",
-      "target": { "claude": ".claude/commands/claude-led-codex-review.md" }
+      "source": "commands/nekowork-full-cycle.md",
+      "target": { "claude": ".claude/commands/nekowork-full-cycle.md" }
     },
 
     "hook:gateguard-fact-force": {

package/manifests/install-modules.json

@@ -76,12 +76,12 @@
       "required": false
     },
     "codex-loop": {
-      "description": "claude-led-codex-review 7단계 풀사이클 + Codex 검증 루프",
+      "description": "nekowork-full-cycle 7단계 풀사이클 + Codex 검증 루프",
       "components": [
-        "skill:claude-led-codex-review",
+        "skill:nekowork-full-cycle",
         "agent:codex-reviewer",
         "agent:codex-challenger",
-        "command:claude-led-codex-review"
+        "command:nekowork-full-cycle"
       ],
       "level": 3,
       "required": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ps-neko/nekowork",
-  "version": "0.1.0-alpha.11",
+  "version": "0.1.0-alpha.12",
   "description": "Verifies AI-made code changes before apply with Codex verification, Human Gate, and explicit apply",
   "keywords": [
     "claude",
@@ -50,7 +50,11 @@
     "scripts/",
     "bridge/",
     "examples/",
-    "docs/",
+    "docs/*.md",
+    "docs/assets/**",
+    "docs/case-studies/**",
+    "docs/dev-log/**",
+    "docs/examples/**",
     "SOUL.md",
     "RULES.md",
     "CLAUDE.md",

package/scripts/build-cursor.js

@@ -113,7 +113,7 @@ const cursorrules = `# Auto-generated. agent.yaml + agents/*.md 가 원본.
 
 이 워크스페이스는 HARNESS 카탈로그를 기반으로 한다.
 .cursor/rules/agents/  : 11개 에이전트 (provider/model 메타데이터 포함)
-.cursor/rules/skills/  : ${manifest.skills?.length || 0}개 스킬 (claude-led-codex-review 등)
+.cursor/rules/skills/  : ${manifest.skills?.length || 0}개 스킬 (nekowork-full-cycle 등)
 .cursor/hooks.json     : Cursor 이벤트 (beforeTool/afterTool/...) 어댑터
 
 직접 편집 금지. 변경은 정규 카탈로그(agents/, skills/, agent.yaml)에서 하고

package/scripts/ci/security-hardening.js

@@ -45,7 +45,17 @@ export function isSemverMcpPin(pin) {
   return /@\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(pin);
 }
 
-export function checkSecurityHardening(root = ROOT) {
+export function resolveEffectiveRoot(start) {
+  // Monorepo 자동 감지: packages/<x>/ 에서 호출되면 워크스페이스 루트로 폴백.
+  const candidate = path.resolve(start, '..', '..');
+  if (fs.existsSync(path.join(candidate, 'pnpm-workspace.yaml'))) {
+    return candidate;
+  }
+  return start;
+}
+
+export function checkSecurityHardening(rawRoot = ROOT) {
+  const root = resolveEffectiveRoot(rawRoot);
   const errors = [];
   const warnings = [];
   const stats = {
@@ -56,7 +66,7 @@ export function checkSecurityHardening(root = ROOT) {
     packageSpecs: 0,
   };
 
-  const manifest = readYaml(root, 'agent.yaml', errors);
+  const manifest = readAgentManifest(root, errors);
   const security = manifest?.security || {};
 
   checkDeadManConfig(security, errors);
@@ -171,8 +181,10 @@ function checkMcpPins(servers, security, errors, stats) {
 
 function checkPackageSupplyChain(root, security, errors, stats) {
   if (security.supply_chain?.package_lock_required !== false) {
-    if (!fs.existsSync(path.join(root, 'package-lock.json'))) {
-      errors.push('package-lock.json is required for npm supply-chain reproducibility');
+    const hasNpmLock = fs.existsSync(path.join(root, 'package-lock.json'));
+    const hasPnpmLock = fs.existsSync(path.join(root, 'pnpm-lock.yaml'));
+    if (!hasNpmLock && !hasPnpmLock) {
+      errors.push('package-lock.json or pnpm-lock.yaml is required for supply-chain reproducibility');
     }
   }
 
@@ -227,6 +239,17 @@ function readYaml(root, rel, errors) {
   }
 }
 
+function readAgentManifest(root, errors) {
+  if (fs.existsSync(path.join(root, 'agent.yaml'))) {
+    return readYaml(root, 'agent.yaml', errors);
+  }
+  const monorepoCandidate = path.join(root, 'packages', 'nekowork-cli', 'agent.yaml');
+  if (fs.existsSync(monorepoCandidate)) {
+    return readYaml(path.dirname(monorepoCandidate), 'agent.yaml', errors);
+  }
+  return readYaml(root, 'agent.yaml', errors);
+}
+
 function readJson(root, rel, errors) {
   try {
     return JSON.parse(fs.readFileSync(path.join(root, rel), 'utf8'));

package/scripts/cli.js

@@ -166,7 +166,7 @@ Review loop
   pr-prep ["task"] [--session <id>] [--project-root <dir>] [--json]
                                          generate PR_SUMMARY/RISK_NOTES/TEST_EVIDENCE/CHANGELOG_DRAFT without branch, commit, push, or PR creation
   review "<task>" [--secure] [--fast] [--no-ship] [--no-codex] [--live] [--session <id>] [--project-root <dir>]
-                                         legacy full claude-led-codex-review workflow
+                                         legacy full nekowork-full-cycle workflow
   review-cycle "<task>" [--secure] [--fast] [--no-ship] [--no-codex] [--live] [--session <id>] [--project-root <dir>]
                                          explicit compatibility alias for the legacy full workflow
   plan "<task>" [--project-root <dir>]   ideate + plan only

package/scripts/demo-review.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// claude-led-codex-review 풀사이클 시뮬레이션 (Week 1 데모).
+// nekowork-full-cycle 풀사이클 시뮬레이션 (Week 1 데모).
 // 실제 LLM 호출은 안 함 — 7단계의 핸드오프 파일 / 상태 / round 카운터가 잘 흐르는지만 검증.
 // 사용자 룰("git push 사용자 확인") 우선이라 실 ship 은 안 함.
 
@@ -19,7 +19,7 @@ const NO_SHIP = process.argv.includes('--no-ship');
 const SESSION_DIR = path.join(ROOT, '.harness', 'state', 'sessions', SESSION_ID);
 fs.mkdirSync(path.join(SESSION_DIR, 'handoffs'), { recursive: true });
 
-console.log(`\n=== claude-led-codex-review demo ===`);
+console.log(`\n=== nekowork-full-cycle demo ===`);
 console.log(`session : ${SESSION_ID}`);
 console.log(`task    : ${TASK}`);
 console.log(`flags   : ${SECURE ? '--secure ' : ''}${NO_SHIP ? '--no-ship' : ''}`);

package/scripts/lib/diff-parser.js

@@ -179,7 +179,7 @@ export function addedLines(parsed) {
  *
  * @param {object} opts
  * @param {string} [opts.cwd]            git working directory
- * @param {'working' | 'staged' | 'range'} [opts.mode='working']
+ * @param {'working' | 'staged' | 'range' | 'full'} [opts.mode='working']
  * @param {string} [opts.range]          required when mode='range', e.g. 'main...HEAD'
  * @param {string[]} [opts.extraArgs]    extra args appended after the mode args
  * @param {boolean} [opts.includeUntracked=true]  for mode='working', synthesize
@@ -189,6 +189,23 @@ export function getGitDiff(opts = {}) {
   const cwd = opts.cwd || process.cwd();
   const mode = opts.mode || 'working';
   const includeUntracked = opts.includeUntracked !== false;
+
+  // full-scan: treat the entire tracked file set (plus untracked, unless
+  // disabled) as an all-added diff, so risk rules see every line rather than
+  // only a git delta. This is the onboarding path — run verify-pr on a repo
+  // that has no PR/diff yet, without fabricating a fake change.
+  if (mode === 'full') {
+    const ls = spawnSync('git', ['ls-files'], { cwd, encoding: 'utf8', windowsHide: true });
+    if (ls.error) throw ls.error;
+    if (ls.status !== 0) {
+      throw new Error(`git ls-files exited ${ls.status}: ${ls.stderr || ''}`);
+    }
+    const tracked = (ls.stdout || '').split('\n').map(s => s.trim()).filter(Boolean);
+    let stdout = synthesizeFilesAsDiff(cwd, tracked);
+    if (includeUntracked) stdout += synthesizeUntrackedDiff(cwd);
+    return parseDiff(stdout);
+  }
+
   const args = ['diff', '--no-color', '--no-ext-diff'];
   if (mode === 'staged') args.push('--cached');
   else if (mode === 'range') {
@@ -227,8 +244,22 @@ function synthesizeUntrackedDiff(cwd) {
   const ls = spawnSync('git', ['ls-files', '--others', '--exclude-standard'], { cwd, encoding: 'utf8', windowsHide: true });
   if (ls.status !== 0 || !ls.stdout) return '';
   const files = ls.stdout.split('\n').map(s => s.trim()).filter(Boolean);
+  return synthesizeFilesAsDiff(cwd, files);
+}
+
+/**
+ * Render a list of repo-relative file paths as an all-added unified diff
+ * (every line prefixed `+`). Shared by untracked-file synthesis (working mode)
+ * and whole-tree synthesis (full-scan mode). Non-files and unreadable paths
+ * are skipped silently.
+ *
+ * @param {string} cwd
+ * @param {string[]} relPaths  repo-relative paths
+ * @returns {string} concatenated unified-diff chunks
+ */
+function synthesizeFilesAsDiff(cwd, relPaths) {
   let chunks = '';
-  for (const rel of files) {
+  for (const rel of relPaths) {
     const full = path.join(cwd, rel);
     let content;
     try {

package/scripts/lib/project-detector.js

@@ -47,6 +47,16 @@ const LOCKFILE_TO_PM = {
   'bun.lockb': 'bun',
 };
 
+// 하위 탐색 시 들어가지 않을 디렉토리 (의존성 / 빌드 산출물 / 캐시).
+// 이 안의 언어 마커는 프로젝트 본체의 것이 아니므로 무시한다.
+const EXCLUDED_DIRS = new Set([
+  'node_modules', 'vendor', 'dist', 'build', 'out', 'target',
+  'coverage', 'venv', '.venv', '__pycache__', 'tmp',
+]);
+
+// 하위 탐색 최대 깊이 (root 의 직계 자식이 depth 1).
+const SUBTREE_MAX_DEPTH = 4;
+
 /**
  * Detect what verifications make sense for `root`.
  *
@@ -88,24 +98,34 @@ export function detectProject(root = process.cwd()) {
     baselineAt: new Date().toISOString(),
   };
 
-  const langs = new Set();
+  // 언어 마커는 root 를 우선 검사한다. root 에서 아무 언어도 못 찾았을 때만
+  // (모노레포 / backend 서브디렉토리 등) 제한된 깊이로 하위를 탐색한다.
+  // root 에 마커가 있으면 하위는 보지 않으므로 기존 동작이 그대로 보존된다.
+  const langDirs = new Map(); // type -> 마커가 발견된 디렉토리
   for (const marker of LANGUAGE_MARKERS) {
-    if (exists(path.join(root, marker.file))) langs.add(marker.type);
+    if (exists(path.join(root, marker.file)) && !langDirs.has(marker.type)) {
+      langDirs.set(marker.type, root);
+    }
+  }
+  if (langDirs.size === 0) {
+    for (const { type, dir } of findLanguageMarkersInSubtree(root)) {
+      if (!langDirs.has(type)) langDirs.set(type, dir);
+    }
   }
-  out.languages = [...langs];
+  out.languages = [...langDirs.keys()];
   out.projectType = pickPrimaryLanguage(out.languages);
 
-  if (out.languages.includes('node')) {
-    Object.assign(out, detectNode(root));
+  if (langDirs.has('node')) {
+    Object.assign(out, detectNode(langDirs.get('node')));
   }
-  if (out.languages.includes('rust')) {
-    mergeCommands(out, detectRust(root));
+  if (langDirs.has('rust')) {
+    mergeCommands(out, detectRust(langDirs.get('rust')));
   }
-  if (out.languages.includes('python')) {
-    mergeCommands(out, detectPython(root));
+  if (langDirs.has('python')) {
+    mergeCommands(out, detectPython(langDirs.get('python')));
   }
-  if (out.languages.includes('go')) {
-    mergeCommands(out, detectGo(root));
+  if (langDirs.has('go')) {
+    mergeCommands(out, detectGo(langDirs.get('go')));
   }
 
   for (const file of CI_FILES) {
@@ -131,6 +151,49 @@ function pickPrimaryLanguage(languages) {
   return languages[0];
 }
 
+// root 에서 언어 마커를 못 찾았을 때, 제한된 깊이로 하위 디렉토리를 탐색한다.
+// node_modules / vendor / 빌드 산출물 / 숨김(.) 디렉토리는 건너뛴다.
+// 같은 언어가 여러 곳이면 가장 먼저 만난 디렉토리를 쓴다.
+function findLanguageMarkersInSubtree(root, maxDepth = SUBTREE_MAX_DEPTH) {
+  const found = [];
+  const markerByFile = new Map(LANGUAGE_MARKERS.map(m => [m.file, m.type]));
+
+  const skipDir = (name) => name.startsWith('.') || EXCLUDED_DIRS.has(name);
+
+  const walk = (dir, depth) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && markerByFile.has(entry.name)) {
+        found.push({ type: markerByFile.get(entry.name), dir });
+      }
+    }
+    if (depth >= maxDepth) return;
+    for (const entry of entries) {
+      if (entry.isDirectory() && !skipDir(entry.name)) {
+        walk(path.join(dir, entry.name), depth + 1);
+      }
+    }
+  };
+
+  let rootEntries;
+  try {
+    rootEntries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+  for (const entry of rootEntries) {
+    if (entry.isDirectory() && !skipDir(entry.name)) {
+      walk(path.join(root, entry.name), 1);
+    }
+  }
+  return found;
+}
+
 function detectNode(root) {
   const pkgPath = path.join(root, 'package.json');
   const out = {

package/scripts/lib/router.js

@@ -2,7 +2,7 @@
 // 입력: stage, task, files, ecoMode, riskLevel
 // 출력: { agent, model, provider, rationale, alternatives }
 //
-// SKILL claude-led-codex-review 의 Stage Routing 표 + AGENTS.md 의
+// SKILL nekowork-full-cycle 의 Stage Routing 표 + AGENTS.md 의
 // 권한 매트릭스를 코드로 구현.
 
 import fs from 'node:fs';

package/scripts/orchestrators/review.js

@@ -1,5 +1,5 @@
 // 7단계 review 오케스트레이터.
-// claude-led-codex-review SKILL 의 Stage Routing 표를 코드로 구현.
+// nekowork-full-cycle SKILL 의 Stage Routing 표를 코드로 구현.
 //
 // 핵심 규칙:
 //   - 단계 5/6 의 verdict 가 block 또는 critical/high 발견 시 fix loop (executor 재호출, round++)

package/scripts/orchestrators/verify-pr.js

@@ -50,7 +50,7 @@ export const EXIT_CODE = Object.freeze({
 /**
  * @param {object} opts
  * @param {string} [opts.projectRoot]   default process.cwd()
- * @param {'working' | 'staged' | 'patch' | 'range'} [opts.mode='working']
+ * @param {'working' | 'staged' | 'patch' | 'range' | 'full'} [opts.mode='working']
  * @param {string} [opts.patchPath]     required when mode='patch'
  * @param {string} [opts.range]         required when mode='range'
  * @param {boolean} [opts.write=true]   write evidence + REPORT.md to disk
@@ -155,6 +155,9 @@ function loadDiff({ mode, projectRoot, opts }) {
   if (mode === 'staged') {
     return getGitDiff({ cwd: projectRoot, mode: 'staged' });
   }
+  if (mode === 'full') {
+    return getGitDiff({ cwd: projectRoot, mode: 'full' });
+  }
   return getGitDiff({ cwd: projectRoot, mode: 'working' });
 }
 
@@ -221,7 +224,7 @@ function deriveVerdict({ findings, parsedDiff, checksAvailable }) {
   if (sourceOnly && !checksAvailable.test) {
     return {
       verdict: VERDICT.INSUFFICIENT_EVIDENCE,
-      reason: 'source changed but project has no test command — cannot verify',
+      reason: 'risk scan passed (no blocking findings), but this project has no test command — full verification needs one. This is "not enough evidence", not a failure.',
       apply_allowed: false,
     };
   }
@@ -422,6 +425,7 @@ export function parseVerifyPrArgs(rest = []) {
     const a = rest[i];
     if (a === '--from-working-tree') opts.mode = 'working';
     else if (a === '--from-staged' || a === '--staged') opts.mode = 'staged';
+    else if (a === '--full-scan' || a === '--full') opts.mode = 'full';
     else if (a === '--from-patch') { opts.mode = 'patch'; opts.patchPath = rest[++i]; }
     else if (a === '--range') { opts.mode = 'range'; opts.range = rest[++i]; }
     else if (a === '--project-root') opts.projectRoot = rest[++i];
@@ -449,6 +453,12 @@ export function printVerifyPrSummary(result) {
       console.log(`    - [${f.severity.toUpperCase()}] ${f.title} (${f.file}:${f.line})`);
     }
   }
+  if (decision.verdict === VERDICT.INSUFFICIENT_EVIDENCE) {
+    console.log('');
+    console.log('  i  not a failure — the risk scan passed with no blocking findings.');
+    console.log('     verify-pr just has no test command to fully verify this change.');
+    console.log('     -> add a test script for full verification, or pass --ci-exit-soft to avoid blocking CI.');
+  }
   if (writtenPaths) {
     console.log(`  report         : ${path.relative(process.cwd(), writtenPaths.report).replace(/\\/g, '/')}`);
     console.log(`  decision       : ${path.relative(process.cwd(), writtenPaths.decision).replace(/\\/g, '/')}`);

package/scripts/sync-claude-md.js

@@ -166,7 +166,7 @@ function buildAutoSection() {
 
   lines.push('## 매직 키워드 → 스킬 (명시 옵트인만)');
   lines.push('');
-  lines.push('자동 활성 키워드 감지는 **사용**하지 않는다. 사용자 룰("확인 후 실행") 우선. 모든 스킬은 슬래시 명령(`/claude-led-codex-review`) 또는 CLI(`nekowork review`) 로 명시 호출.');
+  lines.push('자동 활성 키워드 감지는 **사용**하지 않는다. 사용자 룰("확인 후 실행") 우선. 모든 스킬은 슬래시 명령(`/nekowork-full-cycle`) 또는 CLI(`nekowork review`) 로 명시 호출.');
   lines.push('');
 
   lines.push('## 핸드오프 5필드');

package/skills/{claude-led-codex-review → nekowork-full-cycle}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: claude-led-codex-review
+name: nekowork-full-cycle
 description: "Claude 주도 + Codex 위임 7단계 풀사이클 (idea → ship). Week 1 데모 정전(canon)."
 origin: harness-core
 level: 3
@@ -9,7 +9,7 @@ auto_inject_keywords: []
 tags: [workflow, review, codex, primary]
 ---
 
-# claude-led-codex-review
+# nekowork-full-cycle
 
 Claude 가 구현하고 Codex 가 의심하는 7단계 풀사이클. **HARNESS 의 정전 워크플로우.** 자동 활성 키워드는 비워두고 명시 호출만 받는다 (사용자 환경의 "확인 후 실행" 류 룰을 우회하지 않기 위함).
 
@@ -23,7 +23,7 @@ nekowork review "<task>" --no-ship         # 단계 7 생략 (리뷰까지만)
 nekowork review "<task>" --no-codex        # 단계 5·6 스킵 (Codex 검증 생략)
 ```
 
-또는 슬래시: `/claude-led-codex-review <task> [--flags]`
+또는 슬래시: `/nekowork-full-cycle <task> [--flags]`
 
 ## 7단계
 

package/skills/plan-eng-review/SKILL.md

@@ -18,7 +18,7 @@ planner / architect 가 산출한 PRD 와 단계 분해를 락인 직전에 한
 nekowork plan-eng-review <prd-path>
 ```
 
-claude-led-codex-review 단계 2 의 일부로 자동 호출된다.
+nekowork-full-cycle 단계 2 의 일부로 자동 호출된다.
 
 ## 체크리스트
 

package/skills/ralph/SKILL.md

@@ -3,7 +3,7 @@ name: ralph
 description: "PRD AC 가 모두 passes:true 될 때까지 반복 실행. 명시 옵트인만 (사용자 룰: 자동 활성 금지)."
 origin: harness-core
 level: 3
-prerequisites: [tdd-workflow, claude-led-codex-review]
+prerequisites: [tdd-workflow, nekowork-full-cycle]
 conflicts: [auto-merge]
 auto_inject_keywords: []
 tags: [persistent, loop]

package/skills/review/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: review
-description: "claude-led-codex-review 단계 4 (self-review) 실행. critical / high 만 잡는다."
+description: "nekowork-full-cycle 단계 4 (self-review) 실행. critical / high 만 잡는다."
 origin: harness-core
 level: 2
 prerequisites: [tdd-workflow]
@@ -16,7 +16,7 @@ Claude self-review 단계. code-reviewer 에이전트(opus, ro)를 호출해 git
 
 ```bash
 nekowork self-review                  # 단독
-# claude-led-codex-review 의 단계 4 로 자동 호출됨
+# nekowork-full-cycle 의 단계 4 로 자동 호출됨
 ```
 
 ## 입력

package/skills/ship/SKILL.md

@@ -10,7 +10,7 @@ tags: [release, pr]
 
 # ship
 
-claude-led-codex-review 단계 7. 자동 push 는 하지 않는다 (사용자 / CI 환경에서 명시 트리거).
+nekowork-full-cycle 단계 7. 자동 push 는 하지 않는다 (사용자 / CI 환경에서 명시 트리거).
 
 ## 사전 조건 (모두 PASS 필요)
 

package/skills/verified-gate/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: verified-gate
+description: "독립 검증 게이트를 strict 모드로 실행해 review 미실행/경고/위험을 non-zero exit 으로 차단하고, verdict 카드로 ship/no-ship 을 제시한다."
+origin: harness-core
+level: 1
+prerequisites: []
+conflicts: []
+auto_inject_keywords: []
+tags: [gate, verification, strict, ci]
+---
+
+# verified-gate
+
+현재 워킹트리 변경을 **strict 검증 게이트**에 통과시킨다. 일반 `gate` 와 달리 세 가지를 강제한다:
+
+- review 미실행(`not_run`)·실패(`failed`)를 PASS 로 묻지 않고 `PASS_WITH_WARNINGS` 로 가시화한다 (미검증 = 미통과).
+- `--strict` 는 그 경고·위험을 **non-zero exit 으로 차단**한다 — CI 에서 게이트 자체가 빨갛게 빠진다.
+- `decision.json` 은 content-hash 로 `audit.jsonl` 에 결박되어, gate 이후 사후 변조 시 `apply` 가 거부한다.
+
+## 사용 시점
+
+- PR/커밋 직전 ship/no-ship 을 한 번에 판정하고 싶을 때.
+- CI 에서 "검증 안 함"이 "통과"로 새지 않도록 강제하고 싶을 때.
+- 명시 옵트인 전용 — 자동 키워드 활성은 하지 않는다(프로젝트 정책).
+
+## 동작
+
+1. 프로젝트 harness CLI 로 strict 게이트를 실행한다 (`nekoforge` 우선, 없으면 `harness` / `nekowork` 폴백):
+   ```bash
+   nekoforge gate --strict --task "<task-id, 기본 TASK-001>"
+   ```
+2. **exit code 를 신뢰해** 판정하고(verdict 텍스트만 보고 통과시키지 않는다), `.harness/decision.json` 과 `REPORT.md` 를 읽어 **verdict 카드**로 제시한다:
+
+   | exit | verdict | 카드 | 의미 |
+   |---|---|---|---|
+   | 0 | PASS | ✅ | clean. apply 가능 |
+   | 3 | NEEDS_HUMAN_REVIEW / PASS_WITH_WARNINGS | ⚠️ | 사람 검토 필요 (경고·미검증 포함) |
+   | 4 | BLOCK / INSUFFICIENT_EVIDENCE | 🚫 | 차단 (critical / 증거 부족) |
+
+3. no-ship(⚠️/🚫)이면 `REPORT.md` 의 triggered rules·reasons 를 요약하고 다음 행동을 안내한다.
+4. ship-ready(✅)면 `nekoforge apply --approved` 를 **안내만** 한다.
+
+## 원칙
+
+- **apply 를 자동 실행하지 않는다.** 게이트는 판정만, apply 는 사용자의 명시적 승인으로만.
+- 차단은 exit code 로 강제된다(권고가 아니다).
+- 이 스킬은 슬래시 명령이 아니라 스킬+CLI 로 호출한다 (프로젝트의 "슬래시 신규 금지" 정책 준수).

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 HARNESS contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/commands/claude-led-codex-review.md

@@ -1,29 +0,0 @@
----
-description: "Claude 주도 + Codex 위임 7단계 풀사이클. claude-led-codex-review 스킬 호출."
----
-
-# /claude-led-codex-review
-
-이 슬래시 명령은 `claude-led-codex-review` 스킬의 legacy compat 진입점이다. 신규 워크플로우는 스킬에서 정의되지만 슬래시 호출 호환성을 위해 보존.
-
-## 동작
-
-`Skill` 도구로 `claude-led-codex-review` 를 즉시 호출. 인자가 있으면 작업 요약으로 전달, 없으면 사용자에게 한 줄 요약을 요청.
-
-## 인자
-
-- `$ARGUMENTS` — 작업 요약 한 줄
-- `--fast` — 단계 1·6 스킵
-- `--secure` — 단계 6 강제
-- `--no-ship` — 단계 7 생략
-
-## 예시
-
-```
-/claude-led-codex-review JWT 검증 미들웨어 추가 --secure
-/claude-led-codex-review 결제 환불 로직 버그 수정
-/claude-led-codex-review --fast 사소한 리팩토링
-/claude-led-codex-review 새 API 엔드포인트 --no-ship
-```
-
-전체 명세는 `skills/claude-led-codex-review/SKILL.md` 참조.