@kodevibe/harness 0.11.5 → 0.11.6

package/README.ko.md

@@ -139,7 +139,7 @@ kode:harness는 세 가지 메커니즘으로 해결합니다:
 |--------|------|---------------------|
 | **`.cursorrules` / `copilot-instructions.md`** | 정적. 상태 영속성 없음, 자기 교정 없음, 세션 간 기억 없음. | 매 세션 업데이트되는 살아있는 state 파일. Direction Guard가 매 요청을 목표와 대조. |
 | **LangChain / CrewAI** | AI 앱 구축용 런타임 오케스트레이션. AI 코딩 에이전트 방향 관리용이 아님. | IDE 안에서 작동하는 마크다운 네이티브 가드레일. 런타임 없음, SDK 없음. |
-| **BMAD / gstack / GSD** | 1인 개발자용. 200+ 파일. 방향 관리 없음. | ~25개 파일 (~17K 토큰). Direction Guard + Decision Log. 멀티 개발자 팀 지원. |
+| **BMAD / gstack / GSD** | 강한 planning/workflow 시스템이지만 proof, state, policy gate의 정직한 실행은 여전히 모델 판단에 많이 의존. | planning 이후 실행 가드레일: Story/Wave pacing, Proof Ledger, deterministic state-check, policy/security evidence gate, 멀티 개발자 state sync. |
 | **"조심하면 되지"** | 잊을 때까지만 동작. LLM은 과거 세션에서 배우지 않음. | 자동화: `wrap-up`이 교훈 캡처, `debug`가 실패 추적, `reviewer`가 state 감사. |
 
 ---
@@ -183,6 +183,25 @@ npm run harness:dependency-scan
 npm run harness:llm-bench:smoke
 ```
 
+설치된 프로젝트에서는 이 저장소를 clone하지 않아도 같은 deterministic guard를 실행할 수 있습니다:
+
+```bash
+npx @kodevibe/harness guard --dir .
+npx @kodevibe/harness guard --all --dir .
+npx @kodevibe/harness guard --wrap-up --dir .
+npx @kodevibe/harness guard --state-sync --dir .
+```
+
+GitHub Actions에서 같은 검사를 강제하려면
+`templates/github-actions/kode-harness-guard.yml`을 대상 프로젝트의
+`.github/workflows/kode-harness-guard.yml`로 복사하세요. 이 템플릿은
+deterministic proof/state/security/policy guard가 실패하면 PR/push를 막습니다:
+
+```yaml
+- run: npx --yes @kodevibe/harness guard --all --dir .
+- run: npx --yes @kodevibe/harness guard --state-sync --dir .
+```
+
 릴리즈 증거로 인정하려면 예시 fixture 대신 실제 3개 이상 모델 tier의 sealed result를 `docs/llm-bench-results.json`에 기록한 뒤 실행하세요. 각 run은 `docs/llm-bench-scenarios.json`의 표준 시나리오를 사용해야 하며, `capturedAt`, 일치하는 `promptHash`, `outputHash` 또는 `transcriptHash`가 필요합니다.
 
 ```bash
@@ -394,22 +413,21 @@ Bootstrap이 `docs/crew/`, `docs/PM/`, `docs/Analyst/`, `docs/ARB/`에서 crew
 
 ### 다른 프레임워크와의 비교
 
-| | BMAD v6.2.2 | gstack v0.15.1 | GSD v1.33.0 | **kode:harness** |
+| | BMAD v6.x | gstack v0.15.1 | GSD v1.33.0 | **kode:harness** |
 |---|---|---|---|---|
-| 초점 | 기업 SDLC 방법론 | 1인 소프트웨어 팩토리 | 전체 수명주기 자동화 | **멀티 개발자 방향 정렬** |
-| 파일 수 | 200+ | ~40 | 수백 개 | **~25** |
-| 의존성 | Node 20+ | Bun + Node + Playwright | Node 18+ | **Zero** |
-| IDE 지원 | 20+ (installer) | 5 (setup --host) | 13 (runtime select) | 6 (네이티브 포맷) |
-| 방향 관리 | ❌ | ❌ | ❌ | ✅ (Direction Guard + pivot + Decision Log) |
-| Iron Laws (코드 품질 규칙) | ❌ | ❌ | ❌ | ✅ (11개 규칙이 스킬에 임베딩) |
-| Cold start | ❌ | ❌ | `/gsd-new-project` | ✅ (`setup` 스킬) |
-| 태스크당 컨텍스트 | 4-6 파일 | 1 파일 | 매번 200k 플랜 | **2-3 파일 (136줄 디스패처)** |
+| 핵심 강점 | Planning과 agile workflow 생태계 | 1인 실행 루프 | 전체 수명주기 자동화 | **planning 이후 execution governance** |
+| 최적 영역 | ideation, PRD, architecture, role workflow | 개인 소프트웨어 팩토리 | 넓은 자동화 표면 | **Story/Wave 구현, proof, reviewer, state, policy gate** |
+| Planning 깊이 | 강함 | 중간 | 강함 | 외부 planning 산출물, 특히 kode:crew 산출물을 소비 |
+| 실행 proof gate | checklist/workflow 중심 | tool-flow 중심 | runtime-flow 중심 | **Deterministic Proof Ledger + state-check + reviewer gate** |
+| 정책/보안 governance | 커스터마이징 가능하나 핵심 차별점은 아님 | 제한적 | 다양함 | **Policy Evidence Ledger, secure check, dependency/state sync guard** |
+| 팀 state | artifact/workflow 기반 | 개인 중심 | 자동화 기반 | **공유 docs + 개인 `.harness` state로 멀티 개발자 작업 지원** |
+| 정직한 주장 | BMAD는 planning/workflow 폭에서 더 성숙 | 개인 루프에 강함 | 자동화 표면이 넓음 | **execution truth에서 더 강해야 함: unproven Done, weak evidence, policy overclaim 차단** |
 
 ---
 
 ## 로드맵
 
-kode:harness는 현재 **v0.11.5** — R16 recovery guard 기반 위에 R17 governance hardening(Crew Validation Tracker drift, dependency-map interface log drift, VS Code root instruction anchoring)을 추가했습니다.
+kode:harness는 현재 **v0.11.6** — R17 governance hardening 기반 위에 설치 프로젝트용 CLI/CI guard enforcement를 추가했습니다. 공개 `guard` 커맨드, `guard --all`/`--state-sync` GitHub Actions 템플릿, CLI 노출 회귀 테스트가 포함됩니다.
 
 | 단계 | 버전 | 상태 | 초점 |
 |------|------|------|------|
@@ -428,7 +446,8 @@ kode:harness는 현재 **v0.11.5** — R16 recovery guard 기반 위에 R17 gove
 | **Deterministic Release Guard** | v0.11.2 | ✅ 완료 | R1-R10 guard scripts, package-boundary scan, dependency-map scan, R10 manifest-sealed bench workflow |
 | **Experiment Hardening** | v0.11.3 | ✅ 완료 | R15 Recent Changes integrity, Wave Scope boundary drift checks, enum/filter coverage honesty |
 | **Recovery Hardening** | v0.11.4 | ✅ 완료 | R16 false PASS claim guard, surface-specific Story Contract checks, reviewer dependency evidence, dirty wrap-up guard |
-| **Governance Hardening** | v0.11.5 | ✅ 현재 | R17 Crew Validation Tracker sync, dependency-map interface log guard, VS Code AGENTS.md instruction anchor |
+| **Governance Hardening** | v0.11.5 | ✅ 완료 | R17 Crew Validation Tracker sync, dependency-map interface log guard, VS Code AGENTS.md instruction anchor |
+| **CLI/CI Guard Enforcement** | v0.11.6 | ✅ 현재 | 설치 프로젝트용 공개 `guard` 커맨드, `guard --all`/`--state-sync` CI 템플릿, CLI 노출 회귀 테스트 |
 | **Docs Bridge** | v0.11.1 | 🧪 Experimental | Project Docs Hub Index, docs-bridge 스킬, visibility 경계를 가진 로컬 docs hub 인덱스 |
 | **Safety & Branding** | v0.9.6 | ✅ 완료 | init overwrite 백업, 배포 파일 pm 네이밍 정리, LICENSE 브랜딩 정리 |
 | **Validation** | v1.0 | 🔜 다음 | 실사용 검증, 사용자 피드백 수집 |

package/README.md

@@ -151,7 +151,7 @@ kode:harness solves this with three mechanisms:
 |----------|-----------|------------------------|
 | **`.cursorrules` / `copilot-instructions.md`** | Static. No state persistence, no self-correction, no cross-session memory. | Living state files that update every session. Direction Guard checks every request against goals. |
 | **LangChain / CrewAI** | Runtime orchestration for building AI apps. Not for directing AI coding agents. | Markdown-native guardrails that work inside your IDE. No runtime, no SDK. |
-| **BMAD / gstack / GSD** | Built for solo developers. 200+ files. No direction management. | ~25 files (~17K tokens). Direction Guard + Decision Log. Multi-developer team support. |
+| **BMAD / gstack / GSD** | Strong planning/workflow systems, but they still rely heavily on the model to honestly execute proof, state, and policy gates. | Execution guardrails after planning: Story/Wave pacing, Proof Ledger, deterministic state-check, policy/security evidence gates, and multi-developer state sync. |
 | **"I'll just be careful"** | Works until you forget. LLMs don't learn from past sessions. | Automated: `wrap-up` captures lessons, `debug` tracks failures, `reviewer` audits state. |
 
 ---
@@ -184,6 +184,25 @@ npx @kodevibe/harness validate  # verify state files have real content
 npx @kodevibe/harness uninstall --dry-run --ide vscode  # preview safe removal
 ```
 
+Installed projects can run the same deterministic guard without cloning this repo:
+
+```bash
+npx @kodevibe/harness guard --dir .
+npx @kodevibe/harness guard --all --dir .
+npx @kodevibe/harness guard --wrap-up --dir .
+npx @kodevibe/harness guard --state-sync --dir .
+```
+
+To enforce the same checks in GitHub Actions, copy
+`templates/github-actions/kode-harness-guard.yml` to
+`.github/workflows/kode-harness-guard.yml` in the target project. The template
+blocks PRs/pushes when deterministic proof/state/security/policy checks fail:
+
+```yaml
+- run: npx --yes @kodevibe/harness guard --all --dir .
+- run: npx --yes @kodevibe/harness guard --state-sync --dir .
+```
+
 Source repo maintainers can also run the deterministic guard and model-tier evidence checks:
 
 ```bash
@@ -376,20 +395,19 @@ It adds a Project Docs Hub Index to `project-brief.md` with each local source, r
 
 ### How It Compares
 
-| | BMAD v6.2.2 | gstack v0.15.1 | GSD v1.33.0 | kode:harness |
+| | BMAD v6.x | gstack v0.15.1 | GSD v1.33.0 | kode:harness |
 |---|---|---|---|---|
-| Focus | Enterprise SDLC methodology | 1-person software factory | Full lifecycle automation | **Multi-developer direction alignment** |
-| Files | 200+ | ~40 | Hundreds | ~25 |
-| Dependencies | Node 20+ | Bun + Node + Playwright | Node 18+ | Zero |
-| IDE support | 20+ (installer) | 5 (setup --host) | 13 (runtime select) | 6 (native format) |
-| Direction management | ❌ | ❌ | ❌ | ✅ (Direction Guard + pivot + Decision Log) |
-| Iron Laws (code quality rules) | ❌ | ❌ | ❌ | ✅ (11 laws embedded in skills) |
-| Cold start | ❌ | ❌ | `/gsd-new-project` | ✅ (`setup` skill) |
-| Context per task | 4-6 files | 1 file | Fresh 200k per plan | 2-3 files (136-line dispatcher) |
+| Primary strength | Planning and agile workflow ecosystem | Solo execution loop | Full lifecycle automation | **Execution governance after planning** |
+| Best fit | Ideation, PRD, architecture, role workflows | Personal software factory | Broad automation | **Story/Wave implementation, proof, reviewer, state, policy gates** |
+| Planning depth | Strong | Medium | Strong | Consumes external planning artifacts, especially kode:crew outputs |
+| Execution proof gate | Checklist/workflow driven | Tool-flow driven | Runtime-flow driven | **Deterministic Proof Ledger + state-check + reviewer gates** |
+| Policy/security governance | Customizable, not the core differentiator | Limited | Varies | **Policy evidence ledger, secure checks, dependency/state sync guards** |
+| Team state | Artifact/workflow based | Mostly individual | Automation based | **Shared docs + personal `.harness` state for multi-developer work** |
+| Our honest claim | BMAD is more mature for planning/workflow breadth | Good for solo loops | Broad automation surface | **Must be stronger at execution truth: no unproven Done, no weak evidence, no policy overclaim** |
 
 ## Roadmap
 
-kode:harness is at **v0.11.5** — adds R17 governance hardening for Crew Validation Tracker drift, dependency-map interface log drift, and VS Code root instruction anchoring on top of the R16 recovery guard foundation.
+kode:harness is at **v0.11.6** — adds R20 installed-project CLI/CI guard enforcement, shipping the public `guard` command and GitHub Actions guard template on top of the R17 governance hardening foundation.
 
 | Phase | Version | Status | Focus |
 |---|---|---|---|
@@ -408,7 +426,8 @@ kode:harness is at **v0.11.5** — adds R17 governance hardening for Crew Valida
 | **Deterministic Release Guard** | v0.11.2 | ✅ Complete | R1-R10 guard scripts, package-boundary scan, dependency-map scan, R10 manifest-sealed bench workflow |
 | **Experiment Hardening** | v0.11.3 | ✅ Complete | R15 Recent Changes integrity, Wave Scope boundary drift checks, enum/filter coverage honesty, R15 bench scenarios |
 | **Recovery Hardening** | v0.11.4 | ✅ Complete | R16 false PASS claim guard, surface-specific Story Contract checks, reviewer dependency evidence, dirty wrap-up guard |
-| **Governance Hardening** | v0.11.5 | ✅ Current | R17 Crew Validation Tracker sync, dependency-map interface log guard, VS Code AGENTS.md instruction anchor |
+| **Governance Hardening** | v0.11.5 | ✅ Complete | R17 Crew Validation Tracker sync, dependency-map interface log guard, VS Code AGENTS.md instruction anchor |
+| **CLI/CI Guard Enforcement** | v0.11.6 | ✅ Current | Public `guard` command for installed projects, `guard --all`/`--state-sync` CI template, release regression for CLI exposure |
 | **Docs Bridge** | v0.11.1 | 🧪 Experimental | Project Docs Hub Index, docs-bridge skill, local docs hub index with visibility boundaries |
 | **Safety & Branding** | v0.9.6 | ✅ Done | init overwrite backups, shipped pm naming cleanup, LICENSE branding cleanup |
 | **Validation** | v1.0 | 🔜 Next | Real-world project adoption, user feedback collection |

package/harness/agents/reviewer.md

@@ -174,7 +174,7 @@ After running state-check, also verify:
 - [ ] **docs/project-brief.md**: If a technology or architectural decision was made, is it in Decision Log?
 - [ ] **docs/agent-memory/*.md**: If an agent (reviewer/pm/lead) was used this session, was its memory updated by the wrap-up skill?
 - [ ] **R16 guard evidence**: Run/request the guard command and include its exact summary. Any guard error forbids `DONE`/`DONE_WITH_CONCERNS`:
-  `HARNESS_GUARD_ROOT="$PWD" node /path/to/k-harness/scripts/harness-guard.js docs/project-state.md`
+  `harness guard --dir "$PWD" .harness/project-state.md docs/project-state.md docs/features.md docs/dependency-map.md`
 
 For each missing update: flag as `[STATE-AUDIT]` in the output and provide the exact update that should be made.
 **Severity**:

package/harness/core-rules.md

@@ -6,7 +6,7 @@ Skills and agents work together through shared state files.
 
 ## Quiet Navigator + Confidence Loop
 
-Common-mode users often begin with rough goals. Keep the navigator short and evidence-first:
+Keep navigation short and evidence-first:
 - **Goal Card**: Goal, first usable result, non-goal, risk, required proof.
 - **Proof Ledger**: command/evidence that proves the feature works.
 - **Evidence-Gated Progress Board**: `Planned → Implementing → Proof Pending → Proven → Reviewed`.
@@ -51,24 +51,22 @@ Follow the pipeline that matches the current situation. After each step, output
 <!-- CREW_MODE_START -->
 ### 🟣 Crew-Driven Development (kode:crew artifacts provided)
 
-When external planning artifacts exist (requirements, analysis, design documents from kode:crew or similar):
+When external planning artifacts exist:
 
-1. `setup` → scan project & fill state files, **create Artifact Index + Validation Tracker** in project-brief.md (originals are never modified)
-2. `pm` → plan features **from crew artifacts**: map FR→Stories (`[FR-NNN]` prefix), ARB Fail→P0 Stories (`[ARB-FAIL]` prefix), update Validation Tracker
-3. `lead` → start Story (includes Validation Dashboard showing KPI/FR/ARB coverage)
+1. `setup` → scan project, fill state files, create Artifact Index + Validation Tracker in project-brief.md
+2. `pm` → plan from crew artifacts: map FR→Stories, ARB Fail→P0 Stories, update Validation Tracker
+3. `lead` → start Story with Validation Dashboard
 4. [Coding] → implement Stories in order from pm
 5. `reviewer` → code review + crew artifact compliance check → commit → push
 6. `wrap-up` → capture session lessons + update Validation Tracker + verify push
 
-> Crew artifacts are detected by `docs/crew/`, `docs/PM/`+`docs/Analyst/`+`docs/ARB/`, or explicit requirements/design docs.
-> **Reference, don't summarize**: setup writes an Artifact Index; skills read originals via indexed paths.
-> If `## CI Artifact Index` exists, reviewer Step 2.5 and release Step 3.5 surface the external CI guide when build/CI files change.
-> This pipeline produces the same state files as 🟢 — the difference is the INPUT source and the addition of Validation Tracker for traceability.
+> Reference originals through the Artifact Index; do not rewrite planning artifacts.
+> If `## CI Artifact Index` exists, reviewer/release surface it when build/CI files change.
 <!-- CREW_MODE_END -->
 
 ## User Request Routing
 
-When the user provides a feature request or development goal in their prompt:
+For feature requests:
 
 1. Read `docs/project-state.md` to determine current project state
 2. Route to the appropriate pipeline:
@@ -79,7 +77,7 @@ When the user provides a feature request or development goal in their prompt:
    - Direction change → Start 🟡 Pipeline from `pivot`
    - Docs/wiki request → Run `docs-bridge`
 <!-- CREW_MODE_START -->
-   - Crew artifacts detected (`docs/crew/` exists, `docs/PM/`+`docs/Analyst/`+`docs/ARB/` exist, or user provided design docs) → Start 🟣 Pipeline from `setup`
+   - Crew artifacts detected → Start 🟣 Pipeline from `setup`
 <!-- CREW_MODE_END -->
    - Any other request (info, explanation, status) → `lead` — route with context
 3. Announce which pipeline and step you are starting, then execute
@@ -88,7 +86,7 @@ When the user provides a feature request or development goal in their prompt:
 
 **Every response must end with a 🧭 Next Step block.** This is mandatory — never omit it.
 
-Keep the block concise. When code changed, include the next evidence:
+Keep it concise:
 
 ```
 ---
@@ -102,24 +100,9 @@ Keep the block concise. When code changed, include the next evidence:
 ---
 ```
 
-When a skill or agent reports STATUS: DONE, use the same block and point to the next row in the Chaining Map.
-
-### Chaining Map — what comes after what
-
-| Completed | Next | Prompt Example |
-|-----------|------|---------------|
-| `setup` | `pm` | "[project]에 [첫 기능]을 추가해줘" || `pm` (Step 0 → empty) | `setup` [internal] | "State files empty — auto-invoking setup" || `pm` | User confirmation → `lead` | "이 경로(Plan)대로 구현을 시작할까요?" → "S{N}-{M} Story를 시작해줘" |
-| `lead` (story started) | [Coding] | "S{N}-{M} 구현을 시작해줘" → 완료 후 **새 채팅**에서 `@reviewer` 호출 |
-| [Coding done] | `reviewer` | "S{N}-{M} 코드를 리뷰해줘" |
-| `reviewer` (pass, more stories) | Commit → `lead` | \"커밋 후 다음 Story는?\" |
-| `reviewer` (pass, sprint all done) | Commit → `pm` checkpoint | \"커밋 후 Sprint 완료 — pm checkpoint 실행\" |
-| `reviewer` (STATE-AUDIT) | `wrap-up` | "state 파일을 정리하고 세션 마무리해줘" |
-| `debug` | `reviewer` | "수정한 코드를 리뷰해줘" |
-| `pivot` | `pm` | "변경된 방향에 맞춰 재계획해줘" |
-| `architect` | `pm` | "승인된 설계로 기능을 계획해줘" |
-| `wrap-up` | 🏁 Session End | "다음 세션 시작 시 `lead` 호출" |
+Chaining: `setup→pm→lead→coding→reviewer→wrap-up`. Bug fix: `debug→fix→reviewer→wrap-up`. Pivot: `pivot→pm`. Architecture: `architect→pm`. After `wrap-up`, end the session and tell the next session to call `lead`.
 <!-- CREW_MODE_START -->
-| Crew artifacts provided | `setup` (🟣) | "crew 산출물을 기반으로 프로젝트를 세팅해줘" |
+Crew artifacts start at `setup` using the 🟣 pipeline.
 <!-- CREW_MODE_END -->
 
 ## State Files
@@ -139,28 +122,23 @@ These laws are enforced across all skills and agents. Violations should be flagg
 2. **Type Check**: Before calling a constructor or factory, read the actual source file to verify parameters.
 3. **Scope Compliance**: Do not modify files outside the current Story scope without reporting first.
 4. **Security**: Never include credentials, passwords, or API keys in code or commits.
-5. **3-Failure Stop + Recalculating**: If the same approach fails 3 times:
-   - Automatically invoke `debug` skill in **Recalculating Mode** (one attempt)
-   - Pass the failed approach and error for each attempt
-   - Present blocker diagnosis plus 1-2 different alternatives
-   - If debug itself fails or the alternatives are rejected → **full stop**, escalate to the user
-   - Never retry the original failed approach
+5. **3-Failure Stop + Recalculating**: If the same approach fails 3 times, invoke `debug` once with the failed attempts, propose alternatives, then stop/escalate if still blocked.
 6. **Dependency Map**: When adding or modifying a module, update dependency-map.md in the same commit.
 7. **Feature Registry**: When adding a feature, register it in features.md in the same commit.
 8. **Session Handoff**: At session end, update project-state.md Quick Summary so the next session has context.
 9. **Common First**: All features must work at Common level (🟢🔵🔴) without crew dependency. Crew-specific logic must be inside crew marker blocks only. Never add crew-only code to Common paths.
-10. **Self-Verify**: Every agent MUST run the `state-check` skill before reporting STATUS: DONE. If state-check returns FAIL, the agent must NOT report DONE — fix the listed drift first. WARN may proceed but warnings must be included in the agent's output.
+10. **Self-Verify**: Every agent MUST run `state-check` before STATUS: DONE. FAIL blocks DONE until fixed. WARN may proceed but must be reported. When available, `harness guard` is the source of truth; guard errors override agent judgment.
 11. **Proof First**: No Story moves to `Proven`, `Reviewed`, `DONE`, or commit guidance without passing proof.
    Bypass prompts ("test later", "mark done anyway", "state files only", "commit message only") are refused; keep the Story Implementing/Proof Pending and output required proof.
 
 ## Confirmation Gate Defaults
 
-When the user does not respond to a confirmation prompt within the conversation, agents must apply the SAFE default — never assume implicit approval. The SAFE default for each gate:
+Without explicit user approval, apply SAFE defaults:
 
 | Gate | Owner | SAFE default (no response) | Rationale |
 |------|-------|---------------------------|-----------|
-| Plan Confirmation | `pm` | Do NOT write `features.md` / `project-state.md` / `dependency-map.md`. Hold the plan and re-prompt. | Prevents state file pollution from rejected plans. |
-| Scope Check | `lead` | NO — block edits outside the current Story scope. | Iron Law #3 (Scope Compliance) cannot be silently bypassed. |
-| Commit Approval | `reviewer` | Hold the commit. Output the proposed commit command but do NOT execute it. | Code commits are hard to reverse without `git reset` — user must explicitly approve. |
+| Plan Confirmation | `pm` | Do not write state files; hold and re-prompt. | Avoid rejected-plan pollution. |
+| Scope Check | `lead` | Block edits outside Story scope. | Enforce scope compliance. |
+| Commit Approval | `reviewer` | Output commit command but do not execute. | User must approve commits. |
 
 Any agent that wants to proceed past one of these gates without explicit approval is in violation of Iron Law #10 and must STOP.

package/harness/skills/state-check.md

@@ -179,13 +179,21 @@ This catches wrap-up corruption where `## Recent Changes` is inserted in the mid
 If `docs/project-state.md` or the caller output claims `state-check PASS`, `0 FAIL`, `0 WARN`, or `guard no issues`, the claim must be backed by deterministic evidence:
 
 1. Prefer running the installed guard command:
-   `HARNESS_GUARD_ROOT="$PWD" node /path/to/k-harness/scripts/harness-guard.js docs/project-state.md`
+   `harness guard --dir "$PWD" .harness/project-state.md docs/project-state.md docs/features.md docs/dependency-map.md`
 2. If CLI execution is unavailable, do not claim `0 FAIL, 0 WARN`; say `manual state-check only`.
 3. FAIL if any markdown/state/contract/handoff/env-seal issue is visible while the file claims clean self-verify.
 4. FAIL if the guard output is summarized but not shown.
 
 This catches reports such as "state-check PASS: 0 FAIL, 0 WARN" when a Proof Ledger table is malformed or Environment Seal is missing.
 
+### Check 15: Policy Evidence Truth (R18)
+
+If a Story/ledger claims policy compliance (`policyId`, `pageId`, `Confluence`, `Human Policy`, `LLM Policy Card`, `Machine Guard Spec`): Done/verified needs Confluence MCP fetch, versioned snapshot/hash, or fetch blocker. Local `policy-registry.json` / `/api/policy-evidence` alone is not proof. `TRAP-* → 404` alone FAILs; require scan/diff/storage/guard evidence. Policy UI proof needs screenshot/Playwright/user/manual checklist. Done policy Stories must split Human/LLM/Machine layers.
+
+### Check 16: Proof Contradictions (R19)
+
+FAIL if a passing Proof/Evidence row also says `not observed`, `not verified`, `partial`, `pending`, `missing`, or similar. Split proven/unproven evidence instead.
+
 ## Output Format
 
 ```
@@ -229,6 +237,12 @@ This catches reports such as "state-check PASS: 0 FAIL, 0 WARN" when a Proof Led
 - Guard output: shown / missing
 - Clean PASS claim matches deterministic result: yes/no
 
+### Check 15: Policy Evidence Truth
+- {N} policy rows checked / {M} weak trap rows / {K} missing fetch or snapshot evidence
+
+### Check 16: Proof Contradictions
+- {N} passing proof rows checked / {M} contradictory caveats
+
 <!-- CREW_MODE_START -->
 ### Check 6: Validation Tracker (🟣)
 - {N} FR references checked / {M} drifted

package/harness/skills/wrap-up.md

@@ -145,13 +145,13 @@ For each issue/error that occurred in this session:
 Before saying `state-check PASS`, `0 FAIL`, `0 WARN`, `STATUS: DONE`, or `Session Learn Complete`, run and quote one guard summary:
 
 ```bash
-HARNESS_GUARD_ROOT="$PWD" node /path/to/k-harness/scripts/harness-guard.js docs/project-state.md
+harness guard --wrap-up --dir "$PWD"
 ```
 
-or installed script:
+or, when the package is not globally installed:
 
 ```bash
-npm run harness:guard:wrap-up
+npx @kodevibe/harness guard --wrap-up --dir "$PWD"
 ```
 
 Rules: paste the exact guard summary. Errors block `STATUS: DONE`; warnings must be listed. Never write `0 FAIL, 0 WARN` unless guard says no issues.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodevibe/harness",
-  "version": "0.11.5",
+  "version": "0.11.6",
   "description": "kode:harness — harness engineering for keeping every developer's AI aligned on one project direction.",
   "keywords": [
     "llm",

package/src/guard.js

@@ -25,6 +25,8 @@
 //   R16 checkReviewerAuditEvidence — scope audits must cite real deps/imports
 //   R17 checkCrewValidationSync — Crew Validation Tracker follows done work
 //   R17 checkDependencyInterfaceLog — interface-affecting features update deps
+//   R18 checkPolicyEvidence — policy-pack compliance claims need real evidence
+//   R19 checkProofContradictions — passing proof rows must not carry caveats
 //
 // Severity: 'error' blocks the commit (exit 1). 'warn' is informational.
 
@@ -66,6 +68,8 @@ const SECRET_ALLOWLIST = [
   /\b(?:enum|type|interface|column|field|label)\b/i,
 ];
 
+const SECRET_TEST_FIXTURE_MARKER = /harness-secret-test-fixture/i;
+
 function isAllowlisted(line) {
   return SECRET_ALLOWLIST.some((re) => re.test(line));
 }
@@ -101,6 +105,8 @@ function scanSecrets(content, filename = '') {
   const lines = content.split('\n');
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
+    const previousLine = i > 0 ? lines[i - 1] : '';
+    if (SECRET_TEST_FIXTURE_MARKER.test(line) || SECRET_TEST_FIXTURE_MARKER.test(previousLine)) continue;
     if (isAllowlisted(line)) continue;
     const decodedHit = decodedBase64Secret(line);
     if (decodedHit) {
@@ -837,6 +843,146 @@ function checkSmokeEvidence(content) {
   return violations;
 }
 
+// ─── Proof Contradiction Gate (R19 / execution truth) ────────────────
+
+const PASSING_PROOF_STATUS = /✅|pass(?:ed)?|verified|proven|done|blocked|refused/i;
+const CONTRADICTORY_PROOF_TERMS = /\b(?:not observed|not verified|not proven|not confirmed|not tested|not run|partial(?:ly)?|pending|todo|planned|unverified|missing|incomplete)\b|⬜|🔄|🟡/i;
+
+/**
+ * A proof row cannot both pass and admit that part of the proof was not
+ * observed, is pending, or is partial. This catches "normal risk only; watch /
+ * breached not observed" rows being used to close UI Stories.
+ *
+ * @param {string} content project-state.md
+ * @returns {Array}
+ */
+function checkProofContradictions(content) {
+  const violations = [];
+  const visible = stripHtmlComments(content);
+  const sections = ['Proof Ledger', 'Evidence Summary', 'Policy Evidence Ledger'];
+
+  for (const sectionName of sections) {
+    const rows = parseMarkdownTable(getSection(visible, sectionName) || '');
+    for (const row of rows) {
+      const raw = Object.values(row).filter((v) => typeof v === 'string').join(' ');
+      const result = [row.Result, row.Status, row['Proof Status'], row.result, row.status]
+        .filter((v) => typeof v === 'string')
+        .join(' ');
+      if (!PASSING_PROOF_STATUS.test(result)) continue;
+      if (!CONTRADICTORY_PROOF_TERMS.test(raw)) continue;
+
+      violations.push({
+        check: 'proof-contradiction',
+        severity: 'error',
+        line: 0,
+        message: `${sectionName} has a passing row with contradictory caveats (${raw.slice(0, 140)}). Move the Story back to Proof Pending or split observed and unobserved evidence (R19).`,
+      });
+    }
+  }
+
+  return violations;
+}
+
+// ─── Policy Evidence Gate (R18 / governance execution) ───────────────
+
+const POLICY_GOVERNANCE_TERMS = /\bpolicy(?:-|\s)?pack\b|Policy Evidence Ledger|policy-registry|policyId|pageId|Confluence|Atlassian|Machine Guard Spec|LLM Policy Card|Human Policy/i;
+const POLICY_VERIFIED_STATUS = /✅|verified|proven|pass(?:ed)?|done/i;
+const POLICY_PENDING_STATUS = /pending|not[_ -]?proven|not[_ -]?verified|todo|planned|⬜|🔄|🟡/i;
+const POLICY_FETCH_EVIDENCE = /\b(?:MCP|Atlassian|Confluence)\b[\s\S]{0,80}\b(?:fetch|fetched|read|retrieved|pageVersion|version|snapshot|hash|fetchedAt)\b|\b(?:fetch|fetched|retrieved|snapshot|pageVersion|fetchedAt|hash)\b[\s\S]{0,80}\b(?:MCP|Atlassian|Confluence|pageId)\b/i;
+const POLICY_SURFACE_ONLY_EVIDENCE = /\bAPI returns\b|\bpolicyId\s*\+\s*pageId\b|\bsurfaced?\b|\b4 policies\b|\bregistry\b/i;
+const WEAK_TRAP_404 = /\b(?:TRAP|trap|Secret trap|Dependency trap|PII trap|Proof trap)\b[\s\S]{0,160}\b(?:404|not found|route not found)\b|\b(?:404|not found|route not found)\b[\s\S]{0,160}\b(?:TRAP|trap|blocked|refused)\b/i;
+const STRONG_TRAP_EVIDENCE = /\b(?:forbidden file scan|secret scan|dependency diff|package\.json diff|localStorage scan|sessionStorage scan|PII scan|guard result|policy guard|explicit deny|deny reason|blocked by guard|secure check|state-check)\b/i;
+const POLICY_UI_EVIDENCE = /\bPolicy Evidence Board\b|\bpolicy rows?\b/i;
+const DURABLE_POLICY_UI_EVIDENCE = /\b(?:screenshot|Playwright|browser tool|user[- ]confirmed|observer:\s*user|manual checklist|captured artifact)\b/i;
+const POLICY_LAYER_TERMS = ['Human Policy', 'LLM Policy Card', 'Machine Guard Spec'];
+
+/**
+ * Governance claims are higher-stakes than ordinary feature claims. A policy
+ * row that says "verified" must prove more than "the local JSON was displayed";
+ * trap rows must show a real guard/scan/deny reason, not only an unimplemented
+ * route returning 404. This catches Experiment #8's execution-governance gap.
+ *
+ * @param {string} content project-state.md
+ * @returns {Array}
+ */
+function checkPolicyEvidence(content) {
+  const violations = [];
+  const visible = stripHtmlComments(content);
+  if (!POLICY_GOVERNANCE_TERMS.test(visible)) return violations;
+
+  const storyRows = parseMarkdownTable(getSection(visible, 'Story Status') || '');
+  const donePolicyStories = storyRows.filter((row) => {
+    const raw = Object.values(row).filter((v) => typeof v === 'string').join(' ');
+    return /✅\s*done/i.test(rowStatus(row)) && /policy|governance|evidence/i.test(raw);
+  });
+  const hasDonePolicyStory = donePolicyStories.length > 0;
+
+  const ledgerRows = parseMarkdownTable(getSection(visible, 'Proof Ledger') || '');
+  for (const row of ledgerRows) {
+    const raw = Object.values(row).filter((v) => typeof v === 'string').join(' ');
+    const result = row.Result || row.result || raw;
+
+    if (/(✅|pass|blocked|refused)/i.test(result) && WEAK_TRAP_404.test(raw) && !STRONG_TRAP_EVIDENCE.test(raw)) {
+      violations.push({
+        check: 'policy-evidence',
+        severity: 'error',
+        line: 0,
+        message: 'Policy trap proof uses 404/not-found as the only blocked/refused evidence. Use an explicit guard result, forbidden-file scan, dependency diff, storage scan, or state-check evidence before claiming the trap is blocked (R18).',
+      });
+    }
+
+    if (/(✅|pass)/i.test(result) && POLICY_UI_EVIDENCE.test(raw) && !DURABLE_POLICY_UI_EVIDENCE.test(raw)) {
+      violations.push({
+        check: 'policy-evidence',
+        severity: 'error',
+        line: 0,
+        message: 'Policy Evidence Board UI proof is not durable. Add screenshot/Playwright/browser-tool artifact, user-confirmed observation, or a manual checklist before marking policy UI proof pass (R18).',
+      });
+    }
+  }
+
+  const policyLedger = getSection(visible, 'Policy Evidence Ledger') || '';
+  const policyRows = parseMarkdownTable(policyLedger);
+  for (const row of policyRows) {
+    const raw = Object.values(row).filter((v) => typeof v === 'string').join(' ');
+    const status = row.Status || row.status || '';
+    if (!POLICY_VERIFIED_STATUS.test(status) || POLICY_PENDING_STATUS.test(status)) continue;
+
+    if (!POLICY_FETCH_EVIDENCE.test(raw) && POLICY_SURFACE_ONLY_EVIDENCE.test(raw)) {
+      violations.push({
+        check: 'policy-evidence',
+        severity: 'error',
+        line: 0,
+        message: `Policy ${row['Policy ID'] || row.Policy || '(unknown)'} is marked verified using only local/API surfacing evidence. Record Confluence/MCP fetch, local snapshot with pageVersion/hash, or a fetch blocker before using verified (R18).`,
+      });
+    }
+  }
+
+  if (hasDonePolicyStory) {
+    const hasFetchEvidence = POLICY_FETCH_EVIDENCE.test(visible) || /fetch blocker|MCP blocker|could not fetch/i.test(visible);
+    if (!hasFetchEvidence) {
+      violations.push({
+        check: 'policy-evidence',
+        severity: 'error',
+        line: 0,
+        message: 'A policy/governance Story is done but has no Confluence/MCP fetch evidence, local policy snapshot evidence, or explicit fetch blocker. Local policy-registry display is not enough for policy compliance (R18).',
+      });
+    }
+
+    const missingLayer = POLICY_LAYER_TERMS.find((term) => !visible.includes(term));
+    if (missingLayer) {
+      violations.push({
+        check: 'policy-evidence',
+        severity: 'error',
+        line: 0,
+        message: `A policy/governance Story is done but does not evidence the "${missingLayer}" layer. Policy execution must distinguish Human Policy, LLM Policy Card, and Machine Guard Spec (R18).`,
+      });
+    }
+  }
+
+  return violations;
+}
+
 // ─── Environment Seal Gate (R9) ──────────────────────────────────────
 
 /**
@@ -1286,6 +1432,8 @@ function runGuard({ files, cwd = process.cwd() }) {
       all.push(...checkStoryContracts({ projectState: content }));
       all.push(...checkIntegrationDoD(content));
       all.push(...checkSmokeEvidence(content));
+      all.push(...checkProofContradictions(content));
+      all.push(...checkPolicyEvidence(content));
       all.push(...checkEnvSeal(content));
       if (STATE_LINE_LIMITS[base]) {
         all.push(...lintLineLimit(content, STATE_LINE_LIMITS[base], rel));
@@ -1332,6 +1480,8 @@ module.exports = {
   checkSelfVerifyClaim,
   checkIntegrationDoD,
   checkSmokeEvidence,
+  checkProofContradictions,
+  checkPolicyEvidence,
   checkEnvSeal,
   checkPublicBoundary,
   checkEvaluatorArtifact,

package/src/init.js

@@ -4,6 +4,17 @@ const fs = require('node:fs');
 const path = require('node:path');
 const readline = require('node:readline');
 const crypto = require('node:crypto');
+const { execSync } = require('node:child_process');
+const {
+  runGuard,
+  checkLearnCompletion,
+  checkStateSync,
+  checkCrewValidationSync,
+  checkDependencyInterfaceLog,
+  checkStoryContracts,
+  checkSmokeEvidence,
+  checkScopeSplitApproval,
+} = require('./guard');
 
 const HARNESS_DIR = path.join(__dirname, '..', 'harness');
 const MANIFEST_PATH = '.harness/install-manifest.json';
@@ -179,11 +190,12 @@ const TEAM_GITATTRIBUTES_CONTENT =
   'docs/dependency-map.md merge=union\n';
 
 function hasFrameworkMarker(content) {
+  const legacyHarnessMarker = ['musher', 'engineering'].join('-');
   return content.includes('kode:harness')
     || content.includes('harness engineering')
     || content.includes('@kodevibe/harness')
     || content.includes('harness-engineering')
-    || content.includes('musher-engineering');
+    || content.includes(legacyHarnessMarker);
 }
 
 function hasIdeLayout(targetDir, ide) {
@@ -886,6 +898,135 @@ function runValidate(targetDir) {
   return warnings === 0;
 }
 
+// ─── Guard command ───────────────────────────────────────────
+function readFirstExisting(targetDir, relPaths) {
+  for (const relPath of relPaths) {
+    const fullPath = path.join(targetDir, relPath);
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+      return fs.readFileSync(fullPath, 'utf8');
+    }
+  }
+  return '';
+}
+
+function guardDefaultStateFiles(targetDir) {
+  const candidates = [
+    '.harness/project-state.md',
+    'docs/project-state.md',
+    '.harness/features.md',
+    'docs/features.md',
+    '.harness/dependency-map.md',
+    'docs/dependency-map.md',
+    '.harness/project-brief.md',
+    'docs/project-brief.md',
+  ];
+  return candidates.filter((relPath) => fs.existsSync(path.join(targetDir, relPath)));
+}
+
+function guardGitFiles(targetDir, command) {
+  try {
+    const out = execSync(command, {
+      cwd: targetDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out.split('\n').map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function guardGitStagedFiles(targetDir) {
+  return guardGitFiles(targetDir, 'git diff --cached --name-only --diff-filter=ACM');
+}
+
+function guardGitVisibleFiles(targetDir) {
+  return guardGitFiles(targetDir, 'git ls-files --cached --others --exclude-standard')
+    .filter((relPath) => !relPath.startsWith('node_modules/'))
+    .filter((relPath) => !relPath.startsWith('.git/'));
+}
+
+function guardResolveFiles(args) {
+  if (args.files.length > 0) return args.files;
+  if (args.all) return guardGitVisibleFiles(args.dir);
+  if (args.staged) return guardGitStagedFiles(args.dir);
+
+  const staged = guardGitStagedFiles(args.dir);
+  return staged.length > 0 ? staged : guardDefaultStateFiles(args.dir);
+}
+
+function printGuardViolations(violations) {
+  for (const violation of violations) {
+    const icon = violation.severity === 'error' ? '❌' : '⚠️ ';
+    const check = violation.check ? `[${violation.check}] ` : '';
+    const file = violation.file ? `${violation.file}: ` : '';
+    console.log(`    ${icon} ${check}${file}${violation.message}`);
+  }
+}
+
+function printGuardSummary({ errorCount, warnCount, scanned }, okMessage, failMessage) {
+  if (errorCount === 0 && warnCount === 0) {
+    console.log(`  ✅  ${okMessage} (${scanned} file(s) scanned)\n`);
+    return true;
+  }
+  const status = errorCount === 0
+    ? 'guard completed with warnings'
+    : (failMessage || 'guard found blocking issues');
+  console.log(`\n  Result: ${errorCount} error(s), ${warnCount} warning(s) — ${status}\n`);
+  return errorCount === 0;
+}
+
+function runGuardCommand(args) {
+  if (args.wrapUp) {
+    const projectState = readFirstExisting(args.dir, ['.harness/project-state.md', 'docs/project-state.md']);
+    const features = readFirstExisting(args.dir, ['.harness/features.md', 'docs/features.md']);
+    const learn = checkLearnCompletion({ projectState, features, quiet: args.quiet });
+    const guard = runGuard({ files: guardDefaultStateFiles(args.dir), cwd: args.dir });
+    const violations = [...learn, ...guard.violations];
+    const errorCount = violations.filter((v) => v.severity === 'error').length;
+    const warnCount = violations.filter((v) => v.severity === 'warn').length;
+
+    console.log('\n  kode:harness Guard — Learn Completion Gate\n');
+    printGuardViolations(violations);
+    return printGuardSummary(
+      { errorCount, warnCount, scanned: guard.scanned },
+      'wrap-up outputs complete',
+      'session is not safe to close',
+    );
+  }
+
+  if (args.stateSync) {
+    const projectState = readFirstExisting(args.dir, ['.harness/project-state.md', 'docs/project-state.md']);
+    const features = readFirstExisting(args.dir, ['.harness/features.md', 'docs/features.md']);
+    const dependencyMap = readFirstExisting(args.dir, ['.harness/dependency-map.md', 'docs/dependency-map.md']);
+    const projectBrief = readFirstExisting(args.dir, ['.harness/project-brief.md', 'docs/project-brief.md']);
+    const violations = [
+      ...checkStateSync({ projectState, features, dependencyMap }),
+      ...checkDependencyInterfaceLog({ features, dependencyMap }),
+      ...checkCrewValidationSync({ projectState, features, projectBrief }),
+      ...checkStoryContracts({ projectState }),
+      ...checkSmokeEvidence(projectState),
+      ...checkScopeSplitApproval({ projectBrief }),
+    ];
+    const errorCount = violations.filter((v) => v.severity === 'error').length;
+    const warnCount = violations.filter((v) => v.severity === 'warn').length;
+
+    console.log('\n  kode:harness Guard — State Sync Gate\n');
+    printGuardViolations(violations);
+    return printGuardSummary(
+      { errorCount, warnCount, scanned: [projectState, features, dependencyMap, projectBrief].filter(Boolean).length },
+      'state files are synchronized',
+      'state files are not safe to close',
+    );
+  }
+
+  const files = guardResolveFiles(args);
+  const result = runGuard({ files, cwd: args.dir });
+  console.log('\n  kode:harness Guard — Deterministic Guardrail\n');
+  printGuardViolations(result.violations);
+  return printGuardSummary(result, 'no guard issues found', 'guard found blocking issues');
+}
+
 function getKnownIdeFiles(ide) {
   const skillIds = SKILLS.map(skill => skill.id);
   const agentIds = AGENTS.map(agent => agent.id);
@@ -1405,17 +1546,24 @@ function showHelp() {
     npx @kodevibe/harness init [options]
     npx @kodevibe/harness doctor [--dir <path>]
     npx @kodevibe/harness validate [--dir <path>]
+    npx @kodevibe/harness guard [options] [files...]
     npx @kodevibe/harness uninstall [options]
 
   Commands:
     init             Install kode:harness files for your IDE
     doctor           Check if kode:harness files are installed and healthy
     validate         Verify state files have content (not just placeholders)
+    guard            Run deterministic proof/state/security/policy guard
     uninstall        Safely remove kode:harness IDE files (state preserved by default)
 
   Options:
     --ide <name>     IDE target: vscode, claude, cursor, codex, windsurf, antigravity
     --all            Uninstall all detected IDE layouts
+                     With guard: scan all git-visible files
+    --staged         With guard: scan only staged files
+    --wrap-up        With guard: run session-end Learn/proof gate
+    --state-sync     With guard: run cross-state synchronization gate
+    --quiet          With guard --wrap-up: allow zero-change sessions
     --mode <mode>    Project mode: solo (default) or team
     --dir <path>     Target directory (default: current directory)
     --overwrite      Overwrite existing files (including state files)
@@ -1436,6 +1584,8 @@ function showHelp() {
     npx @kodevibe/harness init --ide claude --dir ./my-project
     npx @kodevibe/harness doctor
     npx @kodevibe/harness validate
+    npx @kodevibe/harness guard --wrap-up --dir .
+    npx @kodevibe/harness guard --all --dir .
     npx @kodevibe/harness uninstall --ide claude --dry-run
     npx @kodevibe/harness uninstall --ide claude --yes
 `);
@@ -1459,12 +1609,18 @@ function parseArgs(argv) {
     purgeBackups: false,
     force: false,
     json: false,
+    files: [],
+    staged: false,
+    wrapUp: false,
+    stateSync: false,
+    quiet: false,
   };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === 'init') args.command = 'init';
     else if (arg === 'doctor') args.command = 'doctor';
     else if (arg === 'validate') args.command = 'validate';
+    else if (arg === 'guard') args.command = 'guard';
     else if (arg === 'uninstall') args.command = 'uninstall';
     else if (arg === '--ide' && argv[i + 1]) { args.ide = argv[++i]; }
     else if (arg === '--mode' && argv[i + 1]) { args.mode = argv[++i]; }
@@ -1474,6 +1630,10 @@ function parseArgs(argv) {
     else if (arg === '--overwrite') args.overwrite = true;
     else if (arg === '--batch') args.batch = true;
     else if (arg === '--all') args.all = true;
+    else if (arg === '--staged') args.staged = true;
+    else if (arg === '--wrap-up') args.wrapUp = true;
+    else if (arg === '--state-sync') args.stateSync = true;
+    else if (arg === '--quiet') args.quiet = true;
     else if (arg === '--dry-run') args.dryRun = true;
     else if (arg === '--yes' || arg === '-y') args.yes = true;
     else if (arg === '--purge-state' || arg === '--include-state') args.purgeState = true;
@@ -1482,6 +1642,7 @@ function parseArgs(argv) {
     else if (arg === '--json') args.json = true;
     else if (arg === '--help' || arg === '-h') args.help = true;
     else if (arg === '--version') args.version = true;
+    else if (args.command === 'guard' && !arg.startsWith('-')) args.files.push(arg);
   }
   return args;
 }
@@ -1510,6 +1671,11 @@ async function run(argv) {
     process.exit(ok ? 0 : 1);
   }
 
+  if (args.command === 'guard') {
+    const ok = runGuardCommand(args);
+    process.exit(ok ? 0 : 1);
+  }
+
   if (args.command === 'uninstall') {
     await runUninstall(args);
     return;
@@ -1612,4 +1778,4 @@ async function run(argv) {
   }
 }
 
-module.exports = { run, detectLanguage, runDoctor, runValidate, buildUninstallPlan };
+module.exports = { run, detectLanguage, runDoctor, runValidate, runGuardCommand, buildUninstallPlan };

package/templates/github-actions/kode-harness-guard.yml

@@ -0,0 +1,20 @@
+name: kode:harness Guard
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+jobs:
+  guard:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - name: Deterministic harness guard
+        run: npx --yes @kodevibe/harness guard --all --dir .
+      - name: State synchronization guard
+        run: npx --yes @kodevibe/harness guard --state-sync --dir .