omniconductor 0.4.1 → 0.6.0

package/CHANGELOG.md

@@ -5,6 +5,16 @@ Format follows [Keep a Changelog](https://keepachangelog.com/); versioning is [S
 
 ## [Unreleased]
 
+## [0.6.0] — 2026-07-07
+
+### Added
+- **`loop-engineering` recipe + `pretool-loop-guard` PreToolUse hook** — opt-in discipline for bounded, externally-verified agent loops (G1–G6): explicit done-criterion, iteration+token budget, require-progress, escalate-on-stall, **verify externally never by self-judgment**, oscillation/infinite-loop guard. Grounded in a 5-source verification pass (Huang/DeepMind "Cannot Self-Correct Yet", CRITIC, Reflexion, "When Agents Do Not Stop", Anthropic *Building Effective Agents* — verify hierarchy rules/tests > visual > LLM-judge). The Claude hook is a non-blocking `permissionDecision: ask` soft-warn that self-gates on the recipe, detects same-action-repeat / runaway tool-call budget, is fail-open, and honors `CONDUCTOR_SKIP_LOOP_GUARD` / `CONDUCTOR_LOOP_REPEAT_MAX` / `CONDUCTOR_LOOP_BUDGET` / `CONDUCTOR_LOOP_COOLDOWN_SECONDS`. Recipe count **12 → 13**, hook templates **9 → 10**. Hook is Claude-only (ADR-034); other tools use the rule text. — **ADR-038**.
+
+## [0.5.0] — 2026-07-07
+
+### Added
+- **`git-hygiene` recipe + `stop-git-hygiene-guard` Stop hook** — opt-in shared-repo discipline (G1–G7): no unrequested worktrees, push-don't-hoard, merge=delete-branch, backup≠applied (verify by real code), no reckless force/rebase on shared repos, bundle PRs for CI, session-end hygiene check. Prevents the failure where merged work *looks* lost (orphan worktrees / local-only commit hoarding / stale merged branches) and burns reconciliation time. Recipe body installs on all six tools; the Stop-hook reminder is Claude-only (ADR-034), non-blocking, self-gated on the recipe. Recipe count **11 → 12**, hook templates **7 → 9** (the 0.3.0 `stop-trajectory-log` count was also un-synced). — **ADR-037**.
+
 ## [0.4.1] — 2026-07-06
 
 ### Fixed (docs)

package/README.md

@@ -6,11 +6,11 @@ Write your project's rules, workflow, and discipline ONCE. Install into any AI c
 
 > Born from one year of production iteration at LFamily Labs — the rules, agents, hooks, and memory patterns that survived real shipping pressure.
 
-> **Status (v0.4.0 — 2026-07-05)**: All 6 adapters ship a working `transform.sh` — **Claude Code** (full: rules + hooks + sub-agents + per-call model routing), **Cursor**, **GitHub Copilot** (one install covers 5 IDEs), **Gemini CLI** (`GEMINI.md` + `.gemini/styleguide.md`), **Codex** (`AGENTS.md`), **Windsurf / Devin Desktop** (`.windsurfrules` + `.devin/rules/*.md`). Published to npm as [`omniconductor`](https://www.npmjs.com/package/omniconductor) (v0.4.0). Output is emit-verified (format-validator + CI on all 6); live runtime consumption by Gemini / Codex / Windsurf is adopter-pending — see [`docs/ADAPTER-LIVE-VERIFICATION.md`](./docs/ADAPTER-LIVE-VERIFICATION.md). Manual install ([`docs/MANUAL-INSTALL.md`](./docs/MANUAL-INSTALL.md)) remains a fallback.
+> **Status (v0.6.0 — 2026-07-07)**: All 6 adapters ship a working `transform.sh` — **Claude Code** (full: rules + hooks + sub-agents + per-call model routing), **Cursor**, **GitHub Copilot** (one install covers 5 IDEs), **Gemini CLI** (`GEMINI.md` + `.gemini/styleguide.md`), **Codex** (`AGENTS.md`), **Windsurf / Devin Desktop** (`.windsurfrules` + `.devin/rules/*.md`). Published to npm as [`omniconductor`](https://www.npmjs.com/package/omniconductor) (v0.6.0). Output is emit-verified (format-validator + CI on all 6); live runtime consumption by Gemini / Codex / Windsurf is adopter-pending — see [`docs/ADAPTER-LIVE-VERIFICATION.md`](./docs/ADAPTER-LIVE-VERIFICATION.md). Manual install ([`docs/MANUAL-INSTALL.md`](./docs/MANUAL-INSTALL.md)) remains a fallback.
 >
-> **New in 0.4.0**: instruction-fidelity-first **token economy** — reduce tokens without distorting your instructions: lossless context editing before lossy compaction, an output-brevity discipline, and a new "verbose output" anti-pattern (ADR-035/036; [`docs/CONTEXT-EDITING-GUIDE.md`](./docs/CONTEXT-EDITING-GUIDE.md)). **In 0.3.0**: an opt-in **self-improvement / Reflector loop** (reads session trajectories + git and *proposes* lessons — propose-only — on all six tools; `--recipes=self-improvement`, ADR-030/032/033) + a first-party-verified **compatibility-matrix correction** (all six tools ship hooks / sub-agents / per-task model routing, retiring the old "Claude-only" view; ADR-031). Full history: [`CHANGELOG.md`](./CHANGELOG.md).
+> **New in 0.6.0**: an opt-in **`loop-engineering` recipe** — bounded, externally-verified agent loops (explicit done-criterion, iteration+token budget, require-progress, escalate-on-stall, **verify externally never by self-judgment**, oscillation guard), grounded in a 5-source research pass; Claude adds a non-blocking PreToolUse loop-guard, other tools use the rule text (ADR-038). **In 0.5.0**: **`git-hygiene`** shared-repo discipline (ADR-037). **In 0.4.0**: instruction-fidelity **token economy** (ADR-035/036). **In 0.3.0**: **self-improvement / Reflector loop** (ADR-030/032/033) + compatibility-matrix correction (ADR-031). Full history: [`CHANGELOG.md`](./CHANGELOG.md).
 >
-> Marketplace listing (VSCode Marketplace + Open VSX) remains **Phase 2** (post-0.4) — see ADR-023.
+> Marketplace listing (VSCode Marketplace + Open VSX) remains **Phase 2** (post-0.6) — see ADR-023.
 
 ---
 
@@ -21,7 +21,7 @@ Write your project's rules, workflow, and discipline ONCE. Install into any AI c
 - [Tool coverage matrix](#tool-coverage-matrix)
 - [Install paths (3 options)](#install-paths)
 - [Cross-platform: Mac and Windows](#cross-platform-mac-and-windows)
-- [Recipes catalog (11)](#recipes-catalog)
+- [Recipes catalog (13)](#recipes-catalog)
 - [`transform.sh` options reference](#transformsh-options-reference)
 - [Update / Maintenance / Uninstall](#update--maintenance--uninstall)
 - [Token measurement & KPI baseline](#token-measurement--kpi-baseline)
@@ -74,7 +74,41 @@ bash ~/conductor/adapters/claude/transform.sh . \
 # 5. Claude Code 재시작 → /agents 로 6 에이전트 확인
 ```
 
-다른 도구는 [Install paths](#install-paths) 참조. Windows 는 [Cross-platform](#cross-platform-mac-and-windows) 참조.
+### 설치 방법 (3가지)
+
+- **Path A — `npx` (권장, 클론 불필요)**: `npx omniconductor init --target=<tool> <dir>` — `<tool>` = `claude` / `cursor` / `copilot` / `gemini` / `codex` / `windsurf`. `list` · `--dry-run` · `--recipes=A,B` · `--uninstall` 지원.
+- **Path B — bash 어댑터**: CONDUCTOR 클론 후 `bash adapters/<tool>/transform.sh <dir> [--recipes=...] [--dry-run]`.
+- **Path C — 수동 복사**: 스크립트 없이 `cp`/`cat` 으로. [`docs/MANUAL-INSTALL.md`](./docs/MANUAL-INSTALL.md) 참조.
+- **Windows**: Git Bash 또는 WSL2 — [Cross-platform](#cross-platform-mac-and-windows) 참조.
+
+### Recipe 카탈로그 (13개, opt-in)
+
+5개 universal rule 은 항상 설치되고, recipe 는 프로젝트에 맞게 골라 담습니다 (`--recipes=`).
+
+| Recipe | 설치 시점 |
+|---|---|
+| `coding-conventions` | TypeScript/TSX — 네이밍·Result 패턴·에러 처리 규약 |
+| `monorepo` | npm/pnpm workspaces (apps + packages) |
+| `i18n` | 2개 이상 로케일 — 새 텍스트는 모든 로케일 동시 |
+| `branch-strategy` | main/develop/release 3-브랜치 모델 |
+| `web-mobile-parity` | 웹+모바일 로직 공유 — 버그·기능 양쪽 반영 |
+| `auto-mock-data` | DB 스키마 변경 시 mock seed 자동생성 |
+| `tdd` | 테스트 프레임워크 + Red-Green-Refactor |
+| `debugging` | 재현→원인→수정→회귀테스트 (증상 패치 금지) |
+| `database-discipline` | 관계형 DB — 마이그레이션 우선·접근제어·dev/prod 패리티 |
+| `design-system` | 디자인 토큰 시스템 — 토큰 우선·컴포넌트 재사용·접근성 |
+| `self-improvement` | 세션 회고 Reflector (propose-only, 사람이 승인) |
+| `git-hygiene` | git 프로젝트 (특히 멀티세션/공유 repo) — worktree·push·브랜치 위생 |
+| `loop-engineering` | 에이전트 루프 (fix→verify 반복) — 종료조건·예산·**외부검증** |
+
+### 업데이트 / 제거
+
+- **업데이트**: CONDUCTOR 클론을 `git pull` 후 어댑터 재실행 (또는 `npx omniconductor` 최신 버전).
+- **제거**: `bash adapters/<tool>/transform.sh <dir> --uninstall` — manifest 기반으로 CONDUCTOR 가 넣은 파일만 복원/삭제 (직접 커스터마이즈한 건 보존).
+
+### 상세 레퍼런스 (영문)
+
+도구별 지원 매트릭스, `transform.sh` 전체 옵션, 토큰 측정, 트러블슈팅, FAQ 는 아래 영문 섹션을 참조하세요: [Tool coverage matrix](#tool-coverage-matrix) · [transform.sh options](#transformsh-options-reference) · [Troubleshooting](#troubleshooting) · [FAQ](#faq).
 
 ---
 
@@ -248,7 +282,7 @@ For tools without an adapter (Gemini / Codex / Windsurf), or for adopters in con
 
 ## Recipes catalog
 
-11 opt-in recipes layer project-specific discipline on top of the 5 universal rule bundles. Universal rules always install; recipes are pick-and-mix.
+13 opt-in recipes layer project-specific discipline on top of the 5 universal rule bundles. Universal rules always install; recipes are pick-and-mix.
 
 | Recipe | Install when | Adds |
 |---|---|---|
@@ -263,6 +297,8 @@ For tools without an adapter (Gemini / Codex / Windsurf), or for adopters in con
 | `database-discipline` | Relational store + migrations + dev/prod split | Migration-first schema changes, access-control on new tables, dev/prod parity |
 | `design-system` | Design-token system in use | Tokens over raw hex, component reuse, accessibility + spacing scale adherence |
 | `self-improvement` | Want periodic, human-approved review of your sessions | A **Reflector** reads recent session trajectories + git and **proposes** lessons-learned to `docs/REFLECTION-PROPOSALS.md` (propose-only; you apply). Emits a session-end trajectory hook, a `/reflect` command, a reflector agent, a deterministic prune, and a weekly runner + scheduling guide — on all six tools. See ADR-030/032/033. |
+| `git-hygiene` | Any git project — esp. multi-session/agent repos or protected branches | Shared-repo discipline (G1–G7): no unrequested worktrees, push-don't-hoard, merge=delete-branch, backup≠applied (verify by real code), no reckless force/rebase on shared repos, bundle PRs for CI, session-end hygiene check. Claude adds a non-blocking Stop-hook reminder; other tools use the rule text. See ADR-037. |
+| `loop-engineering` | Any agentic loop (generate→verify→fix→re-verify, test-fix, multi-step) | Bounded, externally-verified loops (G1–G6): explicit done-criterion, iteration+token budget, require-progress, escalate-on-stall, **verify externally never by self-judgment**, oscillation guard. Grounded in the research that self-correction without an external check is unreliable. Claude adds a non-blocking PreToolUse loop-guard (repeat/runaway detection); other tools use the rule text. See ADR-038. |
 
 #### Decision tree
 
@@ -278,6 +314,8 @@ Want root-cause debugging? YES → debugging
 Relational DB + migrations? YES → database-discipline
 Design-token system?      YES → design-system
 Want weekly session self-review? YES → self-improvement
+Use git (esp. shared/multi-session)? YES → git-hygiene
+Agent loops / iterative fix-verify?  YES → loop-engineering
 ```
 
 #### Recommended combos
@@ -302,7 +340,7 @@ Usage: bash adapters/<tool>/transform.sh <target-project> [options]
 | Option | Description |
 |---|---|
 | `<target-project>` | Project directory to install into (required). `.` for current dir. |
-| `--recipes=A,B,C` | Comma-separated recipes from the 11 in `core/recipes/`. |
+| `--recipes=A,B,C` | Comma-separated recipes from the 13 in `core/recipes/`. |
 | `--dry-run` | Preview only — no files written. |
 | `--measure-baseline` | Run `tools/measure-tokens.sh --latest` after install; save CSV; auto-show anti-patterns if cache hit < 95%. |
 | `--no-prompt` | Skip wizard, apply defaults (CI-safe). Combine with `--recipes` and `--measure-baseline` as needed. |
@@ -311,7 +349,7 @@ Usage: bash adapters/<tool>/transform.sh <target-project> [options]
 | `--force` | Bypass uninstall safety gates (active rebase/merge, missing manifest). |
 | `-h` `--help` | Print usage. |
 
-**Recipe names** (11): `web-mobile-parity`, `i18n`, `monorepo`, `branch-strategy`, `auto-mock-data`, `coding-conventions`, `tdd`, `debugging`, `database-discipline`, `design-system`, `self-improvement`.
+**Recipe names** (13): `web-mobile-parity`, `i18n`, `monorepo`, `branch-strategy`, `auto-mock-data`, `coding-conventions`, `tdd`, `debugging`, `database-discipline`, `design-system`, `self-improvement`, `git-hygiene`, `loop-engineering`.
 
 #### File overwrite behavior
 
@@ -410,7 +448,7 @@ diff CLAUDE.md.conductor-backup-* CLAUDE.md
 
 #### "recipe not found" warning
 
-Check recipe name spelling. Available: `web-mobile-parity`, `i18n`, `monorepo`, `branch-strategy`, `auto-mock-data`, `coding-conventions`, `tdd`, `debugging`, `database-discipline`, `design-system`, `self-improvement`.
+Check recipe name spelling. Available: `web-mobile-parity`, `i18n`, `monorepo`, `branch-strategy`, `auto-mock-data`, `coding-conventions`, `tdd`, `debugging`, `database-discipline`, `design-system`, `self-improvement`, `git-hygiene`, `loop-engineering`.
 
 #### "Tool doesn't recognize the new rules"
 
@@ -493,7 +531,7 @@ A: Open VSX. Cursor is a VSCode fork but cannot pull from Microsoft's marketplac
 
 **Q: My project uses Go / Python / Rust, not TypeScript.**
 
-A: Skip `coding-conventions` (TypeScript-specific). The 5 universal rule bundles and the other 10 recipes are stack-agnostic.
+A: Skip `coding-conventions` (TypeScript-specific). The 5 universal rule bundles and the other 12 recipes are stack-agnostic.
 
 **Q: Windows native PowerShell?**
 

package/adapters/claude/README.md

@@ -45,7 +45,7 @@ bash adapters/claude/transform.sh <target> [--dry-run]
 │   │   ├── quality-gates.md
 │   │   ├── operations.md
 │   │   └── meta-discipline.md
-│   ├── hooks/                                 # 7 hook scripts
+│   ├── hooks/                                 # 10 hook scripts
 │   │   ├── pretool-agent-routing.sh
 │   │   ├── pretool-commit-current-work-check.sh
 │   │   ├── pretool-commit-test-coverage-check.sh

package/adapters/claude/SUPPORTED-FEATURES.md

@@ -32,7 +32,7 @@ CONDUCTOR's universal `meta-discipline.md` rubric (token economy + model routing
 
 ## Hook execution model
 
-CONDUCTOR ships 7 hooks, all registered in the generated `.claude/settings.json` (written directly by `transform.sh` — there is no `settings.template.json`):
+CONDUCTOR ships 10 hooks, all registered in the generated `.claude/settings.json` (written directly by `transform.sh` — there is no `settings.template.json`):
 
 | Hook | Event | Purpose |
 |---|---|---|
@@ -58,9 +58,9 @@ The Claude adapter ships a working `transform.sh`. Verified by fresh-target inst
 
 | Feature claim | Verified-by-real-install | Verification command / observation |
 |---|---|---|
-| `transform.sh` emits 6 roles, 5 rules, 7 hooks, settings.json, docs | ✅ | `bash adapters/claude/transform.sh <tmp>` then inspect `<tmp>/.claude/` |
+| `transform.sh` emits 6 roles, 5 rules, 10 hooks, settings.json, docs | ✅ | `bash adapters/claude/transform.sh <tmp>` then inspect `<tmp>/.claude/` |
 | Sub-agent dispatch works | ✅ | `.claude/agents/{planner,builder,reviewer,helper,designer,scribe}.md` recognized by `/help` |
 | Lazy / always-loaded rules present | ✅ | `.claude/rules/{workflow,spec-as-you-go,quality-gates,operations,meta-discipline}.md` |
-| Hooks registered in settings.json | ✅ | `.claude/settings.json` `hooks:` block lists 4 PreToolUse + 3 Stop |
+| Hooks registered in settings.json | ✅ | `.claude/settings.json` `hooks:` block lists 5 PreToolUse + 5 Stop |
 | Stop hook blocks on missing spec update | ✅ | commit code without spec → `stop-session-log-check.sh` fires |
 | Idempotent re-run | ✅ | second run reports "SKIP (exists)" for every emitted file |

package/adapters/claude/transform-spec.md

@@ -31,7 +31,7 @@ core/docs-templates/specs/_example.md
 core/memory-pattern/README.md
 core/memory-pattern/EXAMPLES.md
 core/roles/*.md                                        # 6 role personas → .claude/agents/ (planner/builder/reviewer/helper/designer/scribe)
-core/hooks/*.sh.template                               # 7 hook templates
+core/hooks/*.sh.template                               # 10 hook templates
 adapters/claude/_native/CLAUDE.md.tpl                  # Claude-specific orchestrator manual template
 ```
 

package/adapters/claude/transform.sh

@@ -70,7 +70,7 @@ Options:
                         manifest are preserved.
   --force               Bypass uninstall safety checks (active worktrees, missing manifest)
 
-Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement
+Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering
 EOF
       exit 0
       ;;
@@ -593,7 +593,7 @@ if [ "$IS_ADOPTER_CASE" = "true" ] && [ "$NO_PROMPT" = "false" ] && [ "$DRY_RUN"
   # 3. Select recipes
   echo ""
   echo "Available recipes:"
-  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement"
+  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering"
   printf "Select recipes (comma-separated, or leave blank for none): "
   read -r _recipe_answer
   if [ -n "$_recipe_answer" ]; then
@@ -725,7 +725,7 @@ mkdir_if_real "$TARGET_ABS/.claude/hooks"
 # read guard) emit only if their templates are present in the CONDUCTOR core/ tree, allowing the
 # adapter to remain forward-compatible with P1.7 work in progress.
 INSTALLED_HOOKS=()
-for hook in pretool-agent-routing stop-session-log-check stop-r6-review-check stop-cache-hit-baseline-check pretool-large-file-read-guard pretool-commit-current-work-check pretool-commit-test-coverage-check stop-trajectory-log; do
+for hook in pretool-agent-routing stop-session-log-check stop-r6-review-check stop-cache-hit-baseline-check pretool-large-file-read-guard pretool-commit-current-work-check pretool-commit-test-coverage-check stop-trajectory-log stop-git-hygiene-guard pretool-loop-guard; do
   src="$CORE_ROOT/hooks/$hook.sh.template"
   dest="$TARGET_ABS/.claude/hooks/$hook.sh"
   if [ ! -f "$src" ]; then
@@ -796,6 +796,12 @@ else
         "hooks": [
           { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pretool-large-file-read-guard.sh" }
         ]
+      },
+      {
+        "matcher": "*",
+        "hooks": [
+          { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pretool-loop-guard.sh" }
+        ]
       }
     ],
     "Stop": [
@@ -804,14 +810,15 @@ else
           { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/stop-session-log-check.sh" },
           { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/stop-r6-review-check.sh" },
           { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/stop-cache-hit-baseline-check.sh" },
-          { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/stop-trajectory-log.sh" }
+          { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/stop-trajectory-log.sh" },
+          { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/stop-git-hygiene-guard.sh" }
         ]
       }
     ]
   }
 }
 SETTINGS_EOF
-  log "  wrote $SETTINGS_PATH ($(printf '%s' "${INSTALLED_HOOKS[*]}" | /usr/bin/wc -w | /usr/bin/tr -d ' ') hook(s) installed in .claude/hooks; settings.json registers 8 core hooks: 4 PreToolUse + 4 Stop)"
+  log "  wrote $SETTINGS_PATH ($(printf '%s' "${INSTALLED_HOOKS[*]}" | /usr/bin/wc -w | /usr/bin/tr -d ' ') hook(s) installed in .claude/hooks; settings.json registers 10 core hooks: 5 PreToolUse + 5 Stop)"
   record_emit ".claude/settings.json" "<synthesized>" ""
 fi
 

package/adapters/codex/transform.sh

@@ -75,7 +75,7 @@ Output (single-file Codex model):
   <target>/AGENTS.md    Bundled intro + 5 universal rules + compressed workflow + recipes
   <target>/docs/*.md    Universal doc templates (CURRENT_WORK, REMAINING_TASKS, ...)
 
-Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement
+Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering
 
 What this adapter does NOT install (per ADR-004 honesty):
   - Hook guards (CONDUCTOR emits the Reflector hook when --recipes=self-improvement, ADR-032; other guards remain Claude-only, ADR-034)
@@ -448,7 +448,7 @@ if [ "$IS_ADOPTER_CASE" = "true" ] && [ "$NO_PROMPT" = "false" ] && [ "$DRY_RUN"
 
   echo ""
   echo "Available recipes:"
-  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement"
+  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering"
   printf "Select recipes (comma-separated, or leave blank for none): "
   read -r _recipe_answer
   if [ -n "$_recipe_answer" ]; then

package/adapters/copilot/transform.sh

@@ -87,7 +87,7 @@ Options:
                         Conductor-emitted files when none.
   --force               Bypass uninstall safety checks (active worktrees, missing manifest)
 
-Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement
+Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering
 
 Output (default):
   <target>/.github/copilot-instructions.md            (5 universal rules merged)
@@ -523,7 +523,7 @@ if [ "$IS_ADOPTER_CASE" = "true" ] && [ "$NO_PROMPT" = "false" ] && [ "$DRY_RUN"
 
   echo ""
   echo "Available recipes:"
-  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement"
+  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering"
   printf "Select recipes (comma-separated, blank for none): "
   read -r _recipe_answer
   if [ -n "$_recipe_answer" ]; then

package/adapters/cursor/transform.sh

@@ -67,7 +67,7 @@ Options:
                         manifest are preserved.
   --force               Bypass uninstall safety checks (active worktrees, missing manifest)
 
-Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement
+Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering
 
 What this adapter does NOT install (per ADR-004 honesty + ADR-021):
   - Hook guards (CONDUCTOR emits the Reflector hook when --recipes=self-improvement, ADR-032; other guards remain Claude-only, ADR-034)
@@ -490,7 +490,7 @@ if [ "$IS_ADOPTER_CASE" = "true" ] && [ "$NO_PROMPT" = "false" ] && [ "$DRY_RUN"
 
   echo ""
   echo "Available recipes:"
-  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement"
+  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering"
   printf "Select recipes (comma-separated, or leave blank for none): "
   read -r _recipe_answer
   if [ -n "$_recipe_answer" ]; then

package/adapters/gemini/transform.sh

@@ -71,7 +71,7 @@ Options:
                         manifest are preserved.
   --force               Bypass uninstall safety checks (active worktrees, missing manifest)
 
-Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement
+Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering
 
 Gemini single-file model:
   - All 5 universal rules + selected recipes are bundled into one always-loaded GEMINI.md.
@@ -486,7 +486,7 @@ if [ "$IS_ADOPTER_CASE" = "true" ] && [ "$NO_PROMPT" = "false" ] && [ "$DRY_RUN"
 
   echo ""
   echo "Available recipes:"
-  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement"
+  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering"
   printf "Select recipes (comma-separated, or leave blank for none): "
   read -r _recipe_answer
   if [ -n "$_recipe_answer" ]; then

package/adapters/windsurf/transform.sh

@@ -67,7 +67,7 @@ Options:
                         manifest are preserved.
   --force               Bypass uninstall safety checks (active worktrees, missing manifest)
 
-Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement
+Recipes available: web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering
 
 What this adapter does NOT install (per ADR-004 honesty + ADR-021):
   - Hook guards (CONDUCTOR emits the Reflector hook when --recipes=self-improvement, ADR-032; other guards remain Claude-only, ADR-034)
@@ -453,7 +453,7 @@ if [ "$IS_ADOPTER_CASE" = "true" ] && [ "$NO_PROMPT" = "false" ] && [ "$DRY_RUN"
 
   echo ""
   echo "Available recipes:"
-  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement"
+  echo "  web-mobile-parity, i18n, monorepo, branch-strategy, auto-mock-data, coding-conventions, tdd, debugging, database-discipline, design-system, self-improvement, git-hygiene, loop-engineering"
   printf "Select recipes (comma-separated, or leave blank for none): "
   read -r _recipe_answer
   if [ -n "$_recipe_answer" ]; then

package/core/hooks/README.md

@@ -14,6 +14,8 @@ CONDUCTOR's universal hook spec. Templates here are compiled into native shell s
 | `stop-r6-review-check.sh.template` | Session stop event | Remind to run pre-merge review on open PR | Claude `.claude/hooks/stop-r6-review-check.sh` |
 | `stop-cache-hit-baseline-check.sh.template` | Session stop event | Non-blocking diagnostic — reads the latest session JSONL, computes cache hit rate, reminds when below baseline (token-economy). Fail-open. Override env disables: `CONDUCTOR_SKIP_CACHE_CHECK=1`. | Claude `.claude/hooks/stop-cache-hit-baseline-check.sh` |
 | `stop-trajectory-log.sh.template` | Session stop event | Non-blocking — reads `transcript_path` + `session_id` from the Stop hook's **stdin** (exact provenance; no `~/.claude/projects` dir-scan) and **upserts** one pointer record per session (session id, transcript path, git HEAD, cwd) into `.conductor/trajectories/index.jsonl` for the Reflector (recipes/self-improvement.md). Same stdin approach as the non-Claude portable logger `core/reflector/trajectory-log.sh`. **Opt-in gated: no-ops unless `.conductor/reflect/` exists** (created only by the self-improvement recipe). Anchors to the project root; fail-open. Override: `CONDUCTOR_SKIP_TRAJLOG=1`. | Claude `.claude/hooks/stop-trajectory-log.sh` |
+| `stop-git-hygiene-guard.sh.template` | Session stop event | Non-blocking — detects git-hygiene collapse (extra worktrees, local-only commits not on any remote, abnormally many local branches) and injects a cleanup reminder per `recipes/git-hygiene.md` (G1/G2/G3/G7). **Opt-in gated: no-ops unless `.claude/rules/git-hygiene.md` exists** (created only by the git-hygiene recipe). Anchors to the project root; 15-min cool-down; fail-open, always exits 0. Overrides: `CONDUCTOR_SKIP_GIT_HYGIENE=1`, `CONDUCTOR_GIT_HYGIENE_BRANCH_MAX` (default 20). | Claude `.claude/hooks/stop-git-hygiene-guard.sh` |
+| `pretool-loop-guard.sh.template` | Before each tool call (PreToolUse, `*` matcher) | Non-blocking soft-warn (`permissionDecision: ask`) — tracks a per-session signature of each tool call and surfaces a reminder when the **same action repeats** ≥ `CONDUCTOR_LOOP_REPEAT_MAX` (default 5; oscillation/no-progress) or the session's **total tool calls** ≥ `CONDUCTOR_LOOP_BUDGET` (default 120; runaway), per `recipes/loop-engineering.md` (G2/G3/G6). **Opt-in gated: no-ops unless `.claude/rules/loop-engineering.md` exists.** Per-session cool-down (`CONDUCTOR_LOOP_COOLDOWN_SECONDS`, default 120); trace in `$TMPDIR`, not the repo; fail-open, always exits 0. Override: `CONDUCTOR_SKIP_LOOP_GUARD=1`. | Claude `.claude/hooks/pretool-loop-guard.sh` |
 
 The two `pretool-commit-*` templates are **soft `ask` warns**: they emit
 `{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"ask","permissionDecisionReason":...}}`,

package/core/hooks/pretool-loop-guard.sh.template

@@ -0,0 +1,177 @@
+#!/usr/bin/env bash
+#
+# CONDUCTOR universal hook template
+# hook_id: pretool-loop-guard
+# trigger: pretool
+# action: Before each tool call, track a per-session signature of the call and
+#         soft-warn (non-blocking "ask") when the SAME action repeats too often
+#         (oscillation / no-progress loop) or the session's total tool calls
+#         exceed a budget (runaway loop). Enforces the loop-engineering recipe.
+# compile_targets: claude
+# fallback: rule-text-reminder
+#
+# Generated by adapters/<tool>/transform.sh.
+#
+# Enforces:
+#   - recipes/loop-engineering.md (bound the loop: iteration budget G2, no-progress
+#     halt G3, oscillation/infinite-loop guard G6)
+#
+# Behavior (fail-open, non-blocking):
+#   1. No-op unless the loop-engineering recipe is installed (self-gate on
+#      .claude/rules/loop-engineering.md).
+#   2. Per session, keep a trace of tool-call signatures in a private tmp file.
+#      A "signature" = tool_name + hash(tool_input): identical calls collide.
+#   3. Warn (permissionDecision:ask + reason) when the CURRENT signature has
+#      occurred >= REPEAT_MAX times (same action repeated — likely looping without
+#      progress), OR the session's total tool calls >= BUDGET (runaway). A per-
+#      session cool-down keeps it from firing on every subsequent call.
+#   4. ALWAYS exit 0. Any error, missing input, or missing python3 → allow silently.
+#      "ask" surfaces the reason and routes to the permission flow — it does NOT
+#      hard-block and does NOT auto-approve (same contract as the other pretool
+#      soft-warns).
+#
+# Overrides (runtime env, not compile-time placeholders):
+#   CONDUCTOR_SKIP_LOOP_GUARD=1        disable entirely
+#   CONDUCTOR_LOOP_REPEAT_MAX          same-action repeat threshold (default 5)
+#   CONDUCTOR_LOOP_BUDGET              total tool-calls-per-session threshold (default 120)
+#   CONDUCTOR_LOOP_COOLDOWN_SECONDS    min seconds between warns per session (default 120)
+
+set -u
+
+# Honor opt-out before any work.
+[ "${CONDUCTOR_SKIP_LOOP_GUARD:-}" = "1" ] && exit 0
+
+# Anchor to the project root (emitted hook lives at <project>/.claude/hooks/).
+_self_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd)" || exit 0
+_proj_root="$(cd "$_self_dir/../.." 2>/dev/null && pwd)" || exit 0
+cd "$_proj_root" 2>/dev/null || exit 0
+
+# Self-gate: only act when the loop-engineering recipe is installed.
+[ -f ".claude/rules/loop-engineering.md" ] || exit 0
+
+# Robust JSON handling needs python3; without it, degrade to silent allow.
+command -v /usr/bin/python3 >/dev/null 2>&1 || exit 0
+
+# Read the PreToolUse payload from stdin (no piped stdin → nothing to do).
+export PAYLOAD_RAW="$(/bin/cat 2>/dev/null || true)"
+[ -n "${PAYLOAD_RAW:-}" ] || exit 0
+
+# All logic lives in python for safe parsing / hashing / file IO. It prints EITHER
+# the ask-JSON (when a threshold is crossed and not cooling down) or nothing. Any
+# exception prints nothing → the shell falls through to `exit 0` (allow).
+REPEAT_MAX="${CONDUCTOR_LOOP_REPEAT_MAX:-5}" \
+BUDGET="${CONDUCTOR_LOOP_BUDGET:-120}" \
+COOLDOWN="${CONDUCTOR_LOOP_COOLDOWN_SECONDS:-120}" \
+/usr/bin/python3 -c '
+import json, os, sys, hashlib, re, time, tempfile
+
+def out_nothing():
+    sys.exit(0)
+
+try:
+    raw = os.environ.get("PAYLOAD_RAW", "") or ""
+    d = json.loads(raw)
+    if not isinstance(d, dict):
+        out_nothing()
+
+    tool = d.get("tool_name", "") or ""
+    if not tool:
+        out_nothing()  # no identifiable action → nothing to track
+
+    tool_input = d.get("tool_input", {})
+    session = d.get("session_id", "") or d.get("sessionId", "") or "nosession"
+
+    # Sanitize identifiers used in file paths (defense against path injection).
+    session = re.sub(r"[^A-Za-z0-9_-]", "", str(session))[:64] or "nosession"
+    user = re.sub(r"[^A-Za-z0-9_-]", "", os.environ.get("USER", "") or "unknown")[:32] or "unknown"
+
+    # Thresholds (env-tunable, with safe fallbacks on garbage input).
+    def envint(name, default):
+        try:
+            v = int(os.environ.get(name, "") or default)
+            return v if v > 0 else default
+        except Exception:
+            return default
+    repeat_max = envint("REPEAT_MAX", 5)
+    budget = envint("BUDGET", 120)
+    cooldown = envint("COOLDOWN", 120)
+
+    # Signature = tool + stable hash of its input. Identical calls collide;
+    # a canonical (sorted-key) dump makes key order irrelevant.
+    try:
+        payload = json.dumps(tool_input, sort_keys=True, ensure_ascii=True, default=str)
+    except Exception:
+        payload = repr(tool_input)
+    sig = tool + ":" + hashlib.sha1(payload.encode("utf-8", "replace")).hexdigest()[:16]
+
+    tmp = tempfile.gettempdir()
+    base = os.path.join(tmp, "conductor-loop-%s-%s" % (user, session))
+    trace_path = base + ".trace"
+    cooldown_path = base + ".cooldown"
+
+    # Append this signature, then read the (bounded) trace back.
+    try:
+        with open(trace_path, "a", encoding="utf-8") as f:
+            f.write(sig + "\n")
+    except Exception:
+        out_nothing()  # cannot persist → cannot reason about the loop; allow.
+
+    try:
+        with open(trace_path, "r", encoding="utf-8") as f:
+            lines = f.read().splitlines()
+    except Exception:
+        out_nothing()
+
+    # Bound work: only the last N entries matter for a runaway/oscillation view.
+    if len(lines) > 5000:
+        lines = lines[-5000:]
+
+    total = len(lines)
+    same = sum(1 for x in lines if x == sig)
+
+    hit_repeat = same >= repeat_max
+    hit_budget = total >= budget
+    if not (hit_repeat or hit_budget):
+        out_nothing()
+
+    # Cool-down: at most one warn per `cooldown` seconds per session.
+    now = int(time.time())
+    try:
+        with open(cooldown_path, "r", encoding="utf-8") as f:
+            last = int((f.read().strip() or "0"))
+    except Exception:
+        last = 0
+    if now - last < cooldown:
+        out_nothing()
+    try:
+        with open(cooldown_path, "w", encoding="utf-8") as f:
+            f.write(str(now))
+    except Exception:
+        pass  # cool-down is best-effort; still warn this once.
+
+    if hit_repeat:
+        reason = ("[loop-guard] The same action (%s) has run %d times this session — "
+                  "you may be looping without progress (recipe G3/G6). Before repeating: "
+                  "confirm each iteration changes state, verify with an EXTERNAL check "
+                  "(tests/rules/tool output — not self-judgment), and if stuck after a few "
+                  "tries, stop and ask rather than loop (G4). " % (tool, same))
+    else:
+        reason = ("[loop-guard] %d tool calls this session — approaching a runaway loop "
+                  "(recipe G2 iteration budget). Confirm you are converging on an explicit "
+                  "done-criterion, not spinning. " % total)
+    reason += "(Silence: CONDUCTOR_SKIP_LOOP_GUARD=1; tune CONDUCTOR_LOOP_REPEAT_MAX / CONDUCTOR_LOOP_BUDGET.)"
+
+    print(json.dumps({
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "ask",
+            "permissionDecisionReason": reason,
+        }
+    }))
+except SystemExit:
+    raise
+except Exception:
+    # Absolutely never fail a tool call because of this guard.
+    pass
+'
+exit 0

package/core/hooks/stop-git-hygiene-guard.sh.template

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+#
+# CONDUCTOR universal hook template
+# hook_id: stop-git-hygiene-guard
+# trigger: stop
+# action: On session stop, detect git-hygiene-collapse states (orphan worktrees,
+#         local-only commits, abnormally many local branches) and inject a
+#         non-blocking cleanup reminder per the git-hygiene recipe (G1/G2/G3/G7).
+# compile_targets: claude
+# fallback: rule-text-reminder
+#
+# Generated by adapters/<tool>/transform.sh.
+#
+# Enforces:
+#   - recipes/git-hygiene.md (session-end hygiene: G1 worktrees, G2 push, G3 delete)
+#
+# Behavior (fail-open, non-blocking):
+#   1. No-op unless the git-hygiene recipe is installed (self-gate on
+#      .claude/rules/git-hygiene.md) — the guard ships with every Claude install
+#      but only acts for adopters who opted into the recipe.
+#   2. Reminder only. Emits {"decision":"block","reason":...} to surface the state
+#      to Claude; ALWAYS exits 0. Never hard-fails, never blocks session stop.
+#   3. Cools down (one reminder / 15 min) so it does not nag.
+#
+# Detects the states that make merged work look lost and burn reconciliation time:
+#   - worktrees beyond the main tree (G1),
+#   - local commits not on any remote (`git log --branches --not --remotes`) (G2),
+#   - abnormally high local branch count = merged branches never deleted (G3).
+#
+# Overrides (read at runtime, not compile-time placeholders):
+#   CONDUCTOR_SKIP_GIT_HYGIENE=1       silence for a deliberate transient state
+#   CONDUCTOR_GIT_HYGIENE_BRANCH_MAX   local-branch threshold (default 20)
+
+set -u
+
+[ "${CONDUCTOR_SKIP_GIT_HYGIENE:-}" = "1" ] && exit 0
+
+# Anchor to the project root. The emitted hook lives at <project>/.claude/hooks/,
+# so ../.. is the root — resolves the recipe gate + git checks regardless of cwd.
+_self_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd)" || exit 0
+_proj_root="$(cd "$_self_dir/../.." 2>/dev/null && pwd)" || exit 0
+cd "$_proj_root" || exit 0
+
+# Self-gate: only act when the git-hygiene recipe is installed.
+[ -f ".claude/rules/git-hygiene.md" ] || exit 0
+
+# Not a git repo → nothing to check.
+git rev-parse --git-dir >/dev/null 2>&1 || exit 0
+
+BRANCH_MAX="${CONDUCTOR_GIT_HYGIENE_BRANCH_MAX:-20}"
+
+# (1) Worktrees beyond the main tree.
+WT_COUNT="$(git worktree list 2>/dev/null | /usr/bin/grep -c . )"
+[ -n "$WT_COUNT" ] || WT_COUNT=1
+WT_EXTRA=$((WT_COUNT - 1))
+
+# (2) Local commits not on any remote (unpushed = at-risk / phantom-lost).
+LOCAL_ONLY="$(git log --branches --not --remotes --oneline 2>/dev/null | /usr/bin/grep -c . )"
+[ -n "$LOCAL_ONLY" ] || LOCAL_ONLY=0
+
+# (3) Local branch count (merged branches never deleted accumulate here).
+BRANCHES="$(git for-each-ref --format='%(refname:short)' refs/heads 2>/dev/null | /usr/bin/grep -c . )"
+[ -n "$BRANCHES" ] || BRANCHES=0
+
+# Nothing wrong → allow stop silently.
+if [ "$WT_EXTRA" -le 0 ] && [ "$LOCAL_ONLY" -le 0 ] && [ "$BRANCHES" -le "$BRANCH_MAX" ]; then
+  exit 0
+fi
+
+# Cool-down: at most one reminder per 15 min.
+FLAG="/tmp/conductor-git-hygiene-flag-${USER:-unknown}"
+if [ -f "$FLAG" ]; then
+  LAST="$(/bin/cat "$FLAG" 2>/dev/null || echo 0)"
+  NOW="$(/bin/date +%s 2>/dev/null || echo 0)"
+  if [ "$((NOW - LAST))" -lt 900 ]; then
+    exit 0
+  fi
+fi
+/bin/date +%s > "$FLAG" 2>/dev/null || true
+
+MSGS=""
+[ "$WT_EXTRA" -gt 0 ] && MSGS="${MSGS}${WT_EXTRA} extra git worktree(s) present (G1: remove unless a requested worktree is mid-use). "
+[ "$LOCAL_ONLY" -gt 0 ] && MSGS="${MSGS}${LOCAL_ONLY} local-only commit(s) not on any remote (G2: push them — this is exactly the 'phantom lost/unmerged feature' state). "
+[ "$BRANCHES" -gt "$BRANCH_MAX" ] && MSGS="${MSGS}${BRANCHES} local branches (G3: delete branches whose PRs merged, local+remote). "
+
+/bin/cat <<JSON
+{"decision":"block","reason":"[git-hygiene] ${MSGS}Before ending: run 'git worktree list' + 'git log --branches --not --remotes --oneline' and clean up per the git-hygiene recipe (push local-only work, remove orphan worktrees, delete merged branches). Backup != applied: verify features are on the target branch by real code, not by a backup branch. (Set CONDUCTOR_SKIP_GIT_HYGIENE=1 to silence a deliberate transient state.)"}
+JSON
+exit 0

package/core/recipes/README.md

@@ -2,7 +2,7 @@
 
 Per ADR-013, CONDUCTOR ships project-specific recipes as OPT-IN. They are not loaded by default. Adopters select the recipes that match their project and the adapter wires them into the appropriate native location.
 
-## The 11 recipes
+## The 13 recipes
 
 | File | When to install |
 |---|---|
@@ -17,6 +17,8 @@ Per ADR-013, CONDUCTOR ships project-specific recipes as OPT-IN. They are not lo
 | `database-discipline.md` | Project has a relational store with migrations + dev/prod split. Ships 2 recipe-scoped hookify rules (SQL access-control + SECURITY DEFINER search_path) — see ADR-028 |
 | `design-system.md` | Project maintains a design-token system (color/spacing/typography tokens). Ships 1 recipe-scoped hookify rule (raw-hex-instead-of-token) — see ADR-028 |
 | `self-improvement.md` | Project wants a periodic, human-approved Reflector that distils session lessons into memory/rules. Propose-only; nothing auto-applies. Drives the `reflector` role — see ADR-030 |
+| `git-hygiene.md` | Any git project — esp. repos worked by multiple sessions/agents or with protected branches. Shared-repo discipline (no orphan worktrees, push-don't-hoard, merge=delete-branch, backup≠applied). Ships a Claude-only Stop-hook reminder (`stop-git-hygiene-guard`); other tools use the rule text — see ADR-037 |
+| `loop-engineering.md` | Any agentic loop (generate→verify→fix→re-verify, test-fix, multi-step). Bounded, externally-verified loops: explicit done-criterion, iteration+token budget, require-progress, escalate-on-stall, verify-externally-not-self-judgment, oscillation guard. Ships a Claude-only PreToolUse reminder (`pretool-loop-guard`); other tools use the rule text — see ADR-038 |
 
 ## Selection patterns
 
@@ -27,7 +29,9 @@ Per ADR-013, CONDUCTOR ships project-specific recipes as OPT-IN. They are not lo
 | Multi-locale SaaS | `i18n` + `coding-conventions` + `tdd` + `debugging` |
 | Relational-DB-backed SaaS (migrations + dev/prod) | `database-discipline` + `coding-conventions` + `tdd` + `debugging` |
 | Token-driven design system (theming / dark-mode) | `design-system` + `coding-conventions` + `tdd` + `debugging` |
-| Full-stack SaaS with web + mobile + i18n | All 11 |
+| Full-stack SaaS with web + mobile + i18n | All 13 |
+| Any git repo, esp. shared / multi-session | add `git-hygiene` to any of the above |
+| Agentic / iterative loops (fix-verify, test-fix) | add `loop-engineering` to any of the above |
 | Greenfield experiment | None — universal-rules + roles only is enough |
 
 ## How adapters consume these files

package/core/recipes/git-hygiene.md

@@ -0,0 +1,60 @@
+---
+recipe_id: git-hygiene
+recipe_name: "Git Hygiene / Shared-Repo Discipline"
+applies_when: "any git project — especially repos worked by multiple sessions/agents or with protected branches"
+severity: STRONG (when installed)
+linked_rules:
+  - operations
+  - quality-gates
+  - meta-discipline
+---
+
+# Recipe — Git Hygiene / Shared-Repo Discipline
+
+> Opt-in recipe. Install for any project under git — strongly recommended when more than one session/agent may touch the repo, or when it has protected branches. It codifies the workflow-hygiene habits that stop *completed* work from *looking* lost. Install if you have ever spent time reconciling "where did my feature go" — you likely will again without it.
+
+## Why this exists
+
+Left undisciplined, an agent can turn a healthy repo into one where merged work looks stranded: it spins up `git worktree`s nobody asked for and never cleans them up, hoards commits locally instead of pushing, and never deletes branches after their PRs merge. The classic collapse — dozens of stale local branches, a pile of local-only commits, orphan worktrees — loses *nothing* (it's all merged), but it makes finished work read as **unmerged / lost**, triggers a false "it's only backed up, not applied" scramble, and burns large reconciliation time and trust. Prose alone gets forgotten, so this recipe is backed by a Claude Stop hook (below).
+
+## The 7 obligations
+
+### G1 — No worktrees unless explicitly requested
+The default work model is **normal branches in the single working tree**. Reach for `git worktree` only when the user explicitly asks, or a documented isolation need exists. If you create one, **remove it in the same session** (`git worktree remove`) and delete its branch. An orphan worktree's uncommitted/unpushed work reads as a phantom "lost / unmerged feature" to the next actor.
+
+### G2 — Push, never hoard
+The moment a commit is worth keeping, push it to a **named branch on origin**. Do not accumulate local-only commits. Invariant: at session end `git log --branches --not --remotes` is **empty**. Local-only piles are the direct cause of "unpushed/lost feature" panics and the cost of later diffing what is *actually* missing.
+
+### G3 — Merge means delete
+When a PR merges, immediately delete that branch **both local and remote** (`git branch -d/-D` + `git push origin --delete`). Stale pointers — especially a pre-squash local pointer left after a squash-merge — masquerade as an "unmerged feature" and are the #1 source of the illusion.
+
+### G4 — Backup ≠ applied
+Pushing to an isolated/backup branch is **not** integration. "It's backed up" and "the feature is on the target branch / live" are separate claims. Verify a feature is on your integration/target branch by reading the **actual code** there (file / symbol / value grep), never by the existence of a backup branch. This is `quality-gates.md` Q4 (verify-after-changes) applied to git: a backup is a safety net, never a completion verdict.
+
+### G5 — No reckless branch ops on a shared repo
+No force-push / rebase / reset / branch-move / protected-branch rewrite that a concurrent session or another actor might be building on. Minimize branch churn; when a branch operation's scope or reversibility is unclear, ASK (`meta-discipline.md` AMB-3/AMB-4 — non-trivially-reversible ops and protected-branch writes force ASK). **Another session's uncommitted/unpushed work is inviolable** — back it up and surface it, but never merge/delete/rewrite it on your own judgment.
+
+### G6 — Bundle PRs (CI economy)
+Bundle related work into as few PRs as reasonable — CI runs per PR and free-tier minutes are finite. Do not fragment one change into many PRs that each re-consume CI, and do not push docs-only commits mid-review that re-trigger the whole pipeline. Verify locally before the single push so the one CI run passes first try.
+
+### G7 — Session-end hygiene check
+Before finishing a session: **0 orphan worktrees · 0 local-only commits (all on origin) · merged branches deleted · current branch + working-tree state clear.**
+
+- [ ] `git worktree list` → only the main tree (unless a requested worktree is still mid-use)?
+- [ ] `git log --branches --not --remotes --oneline` → empty?
+- [ ] Merged PR branches deleted (local + remote)?
+- [ ] Not sitting on a stale/behind branch that hides completed work?
+
+## Conductor Integration
+
+- **Claude** — a Stop hook `stop-git-hygiene-guard` (from `core/hooks/`) fires a **non-blocking reminder** when it detects the collapse states: extra worktrees, local-only commits, or an abnormally high local-branch count. It always exits 0 (observation only, never blocks a session), self-gates on this recipe being installed, cools down between reminders, and honors `CONDUCTOR_SKIP_GIT_HYGIENE=1` (silence) and `CONDUCTOR_GIT_HYGIENE_BRANCH_MAX` (branch-count threshold, default 20).
+- **Cursor / Copilot / Gemini / Codex / Windsurf** — the hook is Claude-only (per `docs/DESIGN-DECISIONS.md` ADR-034; Windsurf also lacks Stop-style events). On these tools this recipe's rule text is the enforcement: run the G7 checklist manually at session end.
+- **Target branch** — G2/G3/G4 reference your *integration/target branch* (commonly `main`, or `develop` if you also install the `branch-strategy` recipe). Substitute your project's value.
+
+## Cross-References
+
+- `quality-gates.md` §4 (verify-after-changes) — G4's "verify by real code, not by a backup branch."
+- `meta-discipline.md` §3 (AMB-3/AMB-4) — G5's ASK-before-reckless-branch-op gate.
+- `meta-discipline.md` §5.7 (lossless-before-lossy compaction) — the *uncommitted-durability* layer beneath G2's *unpushed-hygiene* layer; complementary.
+- `branch-strategy.md` recipe — defines the target/integration branch model G2–G4 build on.
+- `core/anti-patterns/frequent-rule-file-edit.md` — G6's "don't re-trigger CI with churn" echoes the cost-of-churn principle.

package/core/recipes/loop-engineering.md

@@ -0,0 +1,73 @@
+---
+recipe_id: loop-engineering
+recipe_name: "Loop Engineering (bounded, externally-verified agent loops)"
+applies_when: "any agentic coding work that iterates — generate→verify→fix→re-verify, test-fix loops, multi-step tasks"
+severity: STRONG (when installed)
+linked_rules:
+  - quality-gates
+  - meta-discipline
+  - workflow
+---
+
+# Recipe — Loop Engineering
+
+> Opt-in recipe. Install for any project where the agent works in a **loop** — "do → check → fix → re-check until done." It codifies how to run that loop so it **terminates correctly, stays bounded, and never declares success without an external check.** Install if you want agent loops that are reliable instead of ones that thrash, run away, or report "done" on unverified work.
+
+## Why this exists
+
+An agent that loops "until it's right" fails in a few well-documented ways. The evidence (peer-reviewed + Anthropic primary sources) is blunt:
+
+- **Self-correction without an external signal is unreliable and can make things WORSE.** Models asked to fix their own work with no external feedback often flip correct answers to wrong ones (*LLMs Cannot Self-Correct Reasoning Yet*, Huang et al., DeepMind, ICLR'24). The real gains come from loops grounded in **tests/tools** (Reflexion, CRITIC), not self-judgment.
+- **"The model says it's done" is not evidence.** LLM self-assessment is systematically over-confident, and LLM-as-judge carries position/verbosity/self-preference bias (*Judging LLM-as-a-Judge*, Zheng et al., NeurIPS'23). Declaring victory without running the check ("early victory") is the most common fidelity failure.
+- **Unbounded loops run away.** Infinite / oscillation (edit↔revert) loops are a documented structural failure — in one study **95.6% ended in cost exhaustion / model-DoS** (*When Agents Do Not Stop*, 2026). More iterations help only up to a point, then *saturate and hurt*; long trajectories degrade (context rot, error compounding).
+
+So a good loop is **bounded, progress-checked, and terminated by an external verifier** — not by the model's opinion. Prose gets forgotten, so on the Claude adapter this recipe is backed by a `pretool-loop-guard` hook.
+
+## The loop shape (well-supported)
+
+```
+Plan → (act → verify) loop → replan on failure → escalate on repeated stall
+```
+
+- **Plan first**, then act (ReAct: interleave reason+act+observe beats act-only).
+- On a failed check, **reflect and replan** using the failure (Reflexion) — not a blind retry.
+- Reserve expensive search/branching (Tree-of-Thoughts) for genuinely exploratory tasks; the default loop stays simple (Anthropic: "the simplest solution possible; add complexity only when it demonstrably improves outcomes").
+
+## The 6 obligations
+
+### G1 — Terminate on an explicit, verified done-criterion
+Before looping, state what "done" IS (a passing test, a matching value, a satisfied spec item). The loop ends when that criterion is **verified true** — never on a vibe or a word-count of effort.
+
+### G2 — Bound the loop (iteration + token budget)
+Set a ceiling before you start: a max number of iterations AND a token/time budget. When the ceiling is hit, **stop and report** (with what's done and what's left) — do not silently keep going. Anthropic ships this as `max_turns` / `max_budget_usd` ("a good default for production agents").
+
+### G3 — Require progress each iteration
+Every pass must change state toward the goal. If an iteration produces no new information or the same result, that is a **no-progress signal** — stop and rethink rather than repeat. (More iterations past the point of progress saturate, then degrade quality.)
+
+### G4 — Escalate on stall, don't loop forever
+After a small number of failed/no-progress iterations (default ~3–5), **hand back to the human** with the state and the blocker, instead of looping. Ties to `meta-discipline.md` AMB — when stuck or the next step is non-trivially reversible, ASK.
+
+### G5 — Verify externally, never by self-judgment (the core rule)
+A loop's exit signal MUST be an **external / ground-truth check** — run the test, execute the code, lint against the rule, diff the value — **not** the model asserting "looks correct." Verify hierarchy (Anthropic, strongest first):
+
+1. **Rules / tests / tool output** — deterministic, best (e.g. run the test suite; lint TS instead of eyeballing).
+2. **Visual / rendered feedback** — screenshots, output diffs.
+3. **LLM-as-judge** — weakest, last resort, and never the sole gate.
+
+This is `quality-gates.md` Q4 (verify-after-changes) applied inside the loop. "Declared done without running the check" = the early-victory anti-pattern; it is a rule violation here.
+
+### G6 — Guard against oscillation / infinite loops
+Detect and break repetition: the same action repeated, or an edit↔revert cycle, means the loop is spinning. Track what you've already tried; if you're repeating, **change approach or escalate (G4)** — never keep re-issuing the same failing action.
+
+## Conductor Integration
+
+- **Claude** — a PreToolUse hook `pretool-loop-guard` (from `core/hooks/`) tracks a per-session signature of each tool call and fires a **non-blocking soft-warn** (`permissionDecision: ask`) when the **same action repeats too often** (G3/G6 — likely looping without progress) or the **session's total tool calls exceed a budget** (G2 — runaway). It self-gates on this recipe being installed, is fail-open (never blocks a tool call on error), and honors `CONDUCTOR_SKIP_LOOP_GUARD=1`, `CONDUCTOR_LOOP_REPEAT_MAX` (default 5), `CONDUCTOR_LOOP_BUDGET` (default 120), `CONDUCTOR_LOOP_COOLDOWN_SECONDS` (default 120).
+- **Cursor / Copilot / Gemini / Codex / Windsurf** — the hook is Claude-only (per `docs/DESIGN-DECISIONS.md` ADR-034/ADR-038). On these tools this recipe's rule text is the enforcement: follow G1–G6 by discipline (the loop shape + external-verify rule are tool-agnostic).
+
+## Cross-References
+
+- `quality-gates.md` §4 (verify-after-changes) — G5's external-verify rule is Q4 applied inside the loop.
+- `meta-discipline.md` §3 (AMB) — G4's escalate-on-stall / ASK-when-stuck gate.
+- `meta-discipline.md` §5.9 (output brevity) + §5.7 — G2's token budget shares the token-economy ceiling.
+- `tdd.md` / `debugging.md` recipes — concrete instances of a G1–G6 loop (Red-Green; reproduce→root-cause→fix→regression).
+- `self-improvement.md` recipe — the session-level Reflector loop is itself a G1–G6 instance (propose → human-verify → apply).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniconductor",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Multi-coding-agent workflow framework. Write your project's rules, workflow, and discipline ONCE — install into Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex, or Windsurf. Encodes the discipline developers most often skip — spec-before-code, review gates, session continuity — so your AI agents catch what's easy to miss.",
   "license": "Apache-2.0",
   "author": "LFamily Labs LLC",