omniconductor 0.3.0

package/VISION.md

@@ -0,0 +1,106 @@
+# VISION — CONDUCTOR
+
+## The problem
+
+> **한글:** AI 코딩 도구가 우후죽순 늘어났습니다. 2026년의 개발자 한 명이 Claude Code (깊은 리팩터), Cursor (IDE 내 페어 프로그래밍), GitHub Copilot (인라인 자동완성 + PR 리뷰), Gemini CLI (저렴한 대용량 컨텍스트 탐색), Codex (셸 기반 작업), Windsurf 를 동시에 쓸 수 있습니다. 그런데 도구마다 룰·컨텍스트 포맷이 제각각입니다. **도구를 바꾸는 순간 그동안 쌓은 규율이 사라집니다.** Claude 용으로 쓴 룰은 Cursor 에서 자동 로드되지 않고, 스스로 훈련해 온 Plan → Architecture → Tasks 워크플로는 다른 에이전트를 여는 순간 증발합니다. 6개월간 다듬은 취향이 통째로 날아갑니다. 이것이 CONDUCTOR 가 푸는 문제입니다.
+
+AI coding tools have multiplied. A single developer in 2026 might use:
+
+- **Claude Code** for deep refactors and multi-file work (Anthropic's CLI agent).
+- **Cursor** for in-IDE pair programming with native completion + chat.
+- **GitHub Copilot** for inline autocomplete and PR review.
+- **Gemini CLI** for cheap large-context exploration.
+- **Codex** (OpenAI) for shell-driven tasks.
+- **Windsurf** when collaborating with someone who prefers it.
+
+Each tool has its own rules-and-context format:
+
+| Tool | Rules file | Rule scoping | Sub-agents | Hooks |
+|---|---|---|---|---|
+| Claude Code | `CLAUDE.md` + `.claude/rules/*.md` + `.claude/agents/*.md` | glob-based via paths front-matter | ✅ Agent tool | ✅ PreToolUse / Stop / etc. |
+| Cursor | `.cursorrules` + `.cursor/rules/*.mdc` | `globs:` front-matter on `.mdc` | ✅ (2.4+) | ✅ (v1.7) |
+| GitHub Copilot | `.github/instructions/*.instructions.md` + AGENTS.md | `applyTo:` front-matter | ✅ | ✅ (CLI + agent) |
+| Gemini CLI | `GEMINI.md` + AGENTS.md (opt-in) | nested-file hierarchy | ✅ | ✅ (v0.26) |
+| Codex | `AGENTS.md` | nested-file hierarchy | ✅ | ✅ |
+| Windsurf / Devin Desktop | `.devin/rules/*.md` (legacy `.windsurf/rules/`) | directory-based | ✅ (Devin Local) | ⚠️ no session/stop events |
+
+> As of 2026, sub-agents and hooks are **no longer Claude-only** — every tool ships them (first-party verified 2026-07-04; see `docs/COMPATIBILITY-MATRIX.md`). CONDUCTOR's problem is unchanged, because what still diverges is the **format**: each tool has a different rules file + scoping syntax, and a rule written for one does not auto-load in another. That portability gap — not a raw capability gap — is what CONDUCTOR closes. (2026년 기준 sub-agent·hook 은 더 이상 Claude 전용이 아니며 모든 도구가 지원합니다. 그럼에도 여전히 **포맷**이 제각각이라 CONDUCTOR 가 푸는 문제는 그대로입니다.)
+
+**Switch tools → lose your discipline.** The rules you wrote for Claude don't auto-load in Cursor. The Plan → Architecture → Tasks workflow you trained yourself to follow disappears the moment you open a different agent. Six months of accumulated taste — gone.
+
+This is the problem CONDUCTOR solves.
+
+## The solution
+
+> **한글:** 프로젝트의 규율을 도구 독립적인 포맷으로 **단 한 번** 작성하세요. 도구별로 명령어 하나만 실행하면, CONDUCTOR 가 해당 도구에 맞는 파일을 올바른 경로·올바른 포맷으로 생성합니다 (`core/` 에 룰을 한 번 쓰면 → `.claude/` / `.cursor/rules/` / `.github/instructions/` / `GEMINI.md` / `.codex/codex.md` / `.windsurfrules` 로 변환). 같은 Plan → Architecture → Tasks 워크플로가, 그날 개발자가 어떤 도구를 쓰든 프로젝트의 모든 에이전트를 동일하게 지배하게 됩니다.
+
+Write your project's discipline ONCE in a tool-agnostic format. Run a single command per tool, and CONDUCTOR generates the right files at the right paths in the right format for that specific tool.
+
+```
+core/                    ← write rules here, ONCE
+  ├── workflow/
+  ├── universal-rules/
+  ├── docs-templates/
+  └── memory-pattern/
+
+  ↓  bash adapters/<tool>/transform.sh <target>   (6 adapters today; an npx wrapper is planned)
+
+target-project/
+  ├── .claude/             (if --target=claude)
+  ├── .cursor/rules/       (if --target=cursor)
+  ├── .github/instructions/ (if --target=copilot)
+  ├── GEMINI.md             (if --target=gemini)
+  ├── AGENTS.md             (if --target=codex)
+  └── .windsurf/rules/      (if --target=windsurf)
+```
+
+The same Plan → Architecture → Tasks workflow now governs every agent in the project, regardless of which tool the developer happens to be using that day.
+
+## Audience
+
+> **한글:** **주 대상**은 AI 코딩 도구로 프로덕션 소프트웨어를 출시하는 1인 개발자와 2~3인 팀입니다. 이들은 룰을 직접 다시 쓰는 당사자이고, 위에서 강제되는 조직 표준이 없기 때문에 도구 전환의 고통을 가장 절실히 느낍니다. 또한 하나의 도구로 표준화하기보다 전술적으로 도구를 골라 씁니다 (빠른 UI 반복은 Cursor, 깊은 리팩터는 Claude). **부 대상**은 서로 다른 AI 도구를 쓰는 기여자들이 모두 같은 프로젝트 컨벤션을 따르길 바라는 오픈소스 메인테이너입니다.
+
+**Primary**: solo developers and 2-3-person teams shipping production software with AI coding tools.
+
+These users feel the tool-switching pain most acutely because they personally do the rule-rewriting and they do not have an org-wide standard imposed from above. They also pick tools tactically (Cursor for fast UI iteration, Claude for deep refactors) instead of standardizing on one.
+
+**Secondary**: open-source maintainers who want contributors using different AI tools to all follow the same project conventions.
+
+## Non-goals
+
+> **한글:** CONDUCTOR 는 의도적으로 다음이 **아닙니다**: 프로젝트 관리 도구가 아니며 (티켓·스프린트·칸반 없음, CURRENT_WORK.md 는 보드가 아니라 텍스트 파일 하나), 엔터프라이즈 팀 관리 제품이 아니며 (SSO·관리자 UI·감사 로그 없음, 1인/소규모 범위), 스스로 학습하는 에이전트가 아니며 (메모리는 사용자가 쓴 것만 쌓이고, 조용히 학습하지 않음. 옵트인 Reflector 가 세션 궤적에서 메모리/룰 변경을 *제안* 할 수 있으나, 사람 승인 없이는 아무것도 적용되지 않습니다 — 제안은 조용한 학습이 아닙니다), 모델 라우터 제품이 아니며 (라우팅은 룰 텍스트일 뿐 실제 추론 프록시를 돌리지 않음), 텔레메트리 벤더가 아니며 (phone-home·사용 통계 없음, 디스크 위 파일뿐), 모든 도구 기능의 상위 집합이 아닙니다 (sub-agent 는 Claude 에만 존재하며, Cursor 에서 셸 프로세스로 가짜 흉내 내지 않고 Layer 3 가 그 한계를 솔직히 인정합니다).
+
+CONDUCTOR is intentionally NOT:
+
+- **A project management tool.** No tickets, no sprints, no Kanban. CURRENT_WORK.md is a single text file, not a board.
+- **An enterprise team-management product.** No SSO, no admin UI, no audit log. Solo / small-team scope only.
+- **A self-improving / agentic auto-learner.** Memory accumulates only what the user (or the orchestrator on the user's behalf) writes. Nothing learns silently. An opt-in Reflector may *propose* memory/rule deltas from session trajectories, but nothing is applied without human approval — proposing is not silent learning.
+- **A model-router product.** Model routing is a *rule* text that travels via CONDUCTOR; the actual routing happens inside Claude Code (and only Claude Code). We do not run an inference proxy.
+- **A telemetry vendor.** No phone-home, no usage stats, no opt-in tracking. Files on disk only.
+- **A super-set of every tool's features.** Sub-agent dispatch only exists in Claude. We refuse to fake it on Cursor by spawning shell processes — that is fragile and confusing. Layer 3 acknowledges these gaps openly.
+
+## Why this can win
+
+1. **Bilingual (한/영) is a moat.** All major competitors (GSD, SpecKit, BMAD, Cursor Rules) are English-first. Korean solo devs are a meaningful early-adopter pool with high willingness to share what works.
+2. **Production-pedigree.** Born from a real shipping project at LFamily Labs — every rule earned through an incident, not theorized in a blog post.
+3. **Honest about limits.** We will not pretend Cursor can do sub-agents. Other multi-tool projects gloss over this; CONDUCTOR's documentation calls it out explicitly. That builds trust.
+4. **Opinionated, light.** GSD has 60+ skills and is a maximalist superset. CONDUCTOR has 5 universal rules + 8 sub-agent definitions and is intentionally a small, opinionated kernel.
+
+## Why this might fail
+
+- **Fragmentation accelerates faster than adapters can keep up.** If 12 new tools launch in 2026, we can't write 12 new adapters.
+  Mitigation: `docs/CONTRIBUTING.md` makes adding a new adapter a well-documented community contribution.
+- **Tools converge on a common format.** If GitHub, Anthropic, OpenAI, Google all agree on `.airules/*.mdc` (unlikely soon), CONDUCTOR's transform layer becomes redundant.
+  Mitigation: even with a common format, the *opinionated* universal-rules content + workflow definitions remain valuable.
+- **Solo-dev market is too narrow.** Maybe everyone settles on one tool.
+  Mitigation: even single-tool users benefit from the rule + agent + workflow library.
+
+## Success in 12 months
+
+By 2027-05:
+
+- 6 tool adapters working end-to-end.
+- 50+ GitHub stars, 5+ community-contributed adapter PRs.
+- The originating LFamily Labs product ships v1.0 using CONDUCTOR as its production scaffold (eat-our-own-dogfood case study).
+- One Korean and one English Show HN / launch tweet.
+- Free and open under Apache 2.0 (commercial use included); the CONDUCTOR name is a trademark of LFamily Labs LLC. File-on-disk, no telemetry.

package/adapters/README.md

@@ -0,0 +1,121 @@
+# `adapters/` — Layer 2, per-tool transformers
+
+One adapter per supported tool. Each reads the tool-agnostic content under `core/` and emits files in the format and at the paths the target tool expects.
+
+## Adapter directory layout
+
+```
+adapters/
+├── claude/        # Claude Code (T1 — full support)
+├── cursor/        # Cursor (T1 — partial; no sub-agents/hooks)
+├── copilot/       # GitHub Copilot (T2)
+├── gemini/        # Gemini CLI (T2)
+├── codex/         # OpenAI Codex (T3)
+└── windsurf/      # Windsurf (T3)
+```
+
+Each adapter directory contains:
+
+| File | Required | Purpose |
+|---|---|---|
+| `README.md` | YES | Tier (T1/T2/T3) with reasoning; what installs; what works; what is lost. |
+| `SUPPORTED-FEATURES.md` | YES | Detailed feature support breakdown for that tool. |
+| `transform-spec.md` | YES | What `transform.sh` MUST do (input, output, edge cases). |
+| `transform.sh` | P1+ | The actual transformer (Bash, idempotent, supports `--dry-run`). |
+| `notes.md` | optional | Real-install discoveries (quirks, surprises). |
+
+## Adapter contract
+
+Every adapter MUST honor:
+
+### 1. Input
+
+- Read from `core/` directory (relative to the conductor repo root).
+- Treat `core/` as read-only. Never modify.
+
+### 2. Output
+
+- Write tool-native files at the conventional path for that tool, into a target directory passed as an argument.
+- Conventional paths per tool are documented in `docs/HOW-IT-WORKS-PER-TOOL.md`.
+- `docs/` templates from `core/docs-templates/` install at `<target>/docs/` for every adapter (universal across tools).
+
+### 3. Idempotency
+
+- Safe to re-run. Existing files at target paths are NOT overwritten — skip and report.
+- Re-running with the same inputs produces the same outputs.
+
+### 4. Dry-run support
+
+- `--dry-run` flag prints what WOULD be written without touching disk.
+- Useful for previewing before installing into a real project.
+
+### 5. No telemetry
+
+- Zero network calls. Zero usage metrics. Zero opt-in tracking. (CONDUCTOR ADR-008.)
+
+### 6. Bash 4+ portability
+
+- `set -euo pipefail` at the top.
+- POSIX-friendly constructs where possible.
+- Quote all variable expansions.
+- Tested on macOS Bash and modern Linux Bash.
+
+### 7. Failure mode
+
+- On error: print to stderr, exit non-zero.
+- On partial success: report what was installed and what was skipped.
+
+## Front-matter translation
+
+The Layer-1 universal-rules use `applies_to:` front-matter for routing hints. Each adapter translates it:
+
+| `core/` front-matter | Adapter output |
+|---|---|
+| `applies_to: ["**/*.ts", "**/*.tsx"]` (Claude) | `paths:\n  - "**/*.ts"\n  - "**/*.tsx"` |
+| (Cursor) | `globs:\n  - "**/*.ts"\n  - "**/*.tsx"` |
+| (Copilot) | `applyTo: '**/*.ts,**/*.tsx'` |
+| (Gemini / Codex) | (bundled — no per-pattern routing) |
+| (Windsurf) | (bundled into `.windsurf/rules/`) |
+
+| `core/` front-matter | Adapter behavior |
+|---|---|
+| `always_loaded: true` | Merge content into the always-loaded baseline file (`CLAUDE.md`, `.cursorrules`, `applyTo: '**'`, `GEMINI.md`, `.codex/codex.md`, `.windsurfrules`) |
+| `always_loaded: false` (or absent) | Emit as a separate rule file with appropriate per-pattern scoping |
+
+## Adapter-specific extensions
+
+Each adapter MAY also install tool-native artifacts that have no `core/` source (because they are Layer-3, tool-only). Examples:
+
+- **Claude adapter** also installs `.claude/agents/*.md`, `.claude/hooks/*.sh`, and a generated `.claude/settings.json` (written by `transform.sh`).
+- **Cursor adapter** also installs `.cursor/commands/*.md` (project commands, where applicable).
+- **Other adapters** typically do NOT have tool-native extensions to install.
+
+These tool-native artifacts live IN THE ADAPTER (not in `core/`) and are documented in the adapter's `transform-spec.md`.
+
+## Running an adapter
+
+The Claude, Cursor, and Copilot adapters ship a runnable `transform.sh`. Gemini, Codex, and Windsurf are manual-install (see `docs/MANUAL-INSTALL.md`); their `transform-spec.md` documents the intended mapping.
+
+Usage (shipping adapters):
+
+```bash
+# Current usage (shipping):
+bash adapters/<tool>/transform.sh <target> [--dry-run]
+
+# Or by absolute path:
+/path/to/conductor/adapters/<tool>/transform.sh /path/to/target [--dry-run]
+
+# (planned / roadmap — not yet available):
+# npx omniconductor init --target=<tool> [target-dir]
+```
+
+## Status (P0 foundation)
+
+All 6 adapter directories have:
+- ✅ `README.md`
+- ✅ `SUPPORTED-FEATURES.md`
+- ✅ `transform-spec.md`
+- ⏳ `transform.sh` (P1+)
+- ⏳ `notes.md` (P1+ when real-install quirks discovered)
+
+See `ROADMAP.md` for which adapter ships in which phase.

package/adapters/claude/README.md

@@ -0,0 +1,102 @@
+# Adapter — Claude Code (T1, full support)
+
+The reference implementation. Claude Code is CONDUCTOR's most-feature-complete target because:
+
+- It supports per-call sub-agent dispatch via the `Agent` tool.
+- It supports hooks (PreToolUse, Stop, etc.) for ABSOLUTE rule enforcement.
+- It supports lazy rule loading via `paths:` front-matter on `.claude/rules/*.md`.
+- It supports per-call model routing via the `model:` argument.
+- It has a built-in per-project memory directory (`~/.claude/projects/<encoded>/memory/`).
+
+**Tier**: T1 — Full.
+
+## Installation path
+
+```bash
+# Current usage (shipping):
+bash adapters/claude/transform.sh <target> [--dry-run]
+
+# Or by absolute path:
+/path/to/conductor/adapters/claude/transform.sh /path/to/target [--dry-run]
+
+# (planned / roadmap — not yet available):
+# npx omniconductor init --target=claude [target-dir]
+
+# Today (P0 foundation): use the v0.1 archive:
+/path/to/conductor/archive/v0.1/install.sh /path/to/target
+```
+
+## What gets installed
+
+```
+<target>/
+├── CLAUDE.md                                  # Slim orchestrator manual (~200 lines)
+├── .claude/
+│   ├── agents/
+│   │   ├── planner.md
+│   │   ├── builder.md
+│   │   ├── reviewer.md
+│   │   ├── helper.md
+│   │   ├── designer.md
+│   │   └── scribe.md
+│   ├── rules/
+│   │   ├── workflow.md
+│   │   ├── spec-as-you-go.md
+│   │   ├── quality-gates.md
+│   │   ├── operations.md
+│   │   └── meta-discipline.md
+│   ├── hooks/                                 # 7 hook scripts
+│   │   ├── pretool-agent-routing.sh
+│   │   ├── pretool-commit-current-work-check.sh
+│   │   ├── pretool-commit-test-coverage-check.sh
+│   │   ├── pretool-large-file-read-guard.sh
+│   │   ├── stop-session-log-check.sh
+│   │   ├── stop-r6-review-check.sh
+│   │   └── stop-cache-hit-baseline-check.sh
+│   └── settings.json                          # Generated by transform.sh (permissions + hooks registry)
+├── docs/
+│   ├── CURRENT_WORK.md
+│   ├── REMAINING_TASKS.md
+│   ├── PLANS.md
+│   ├── TASKS.md
+│   ├── INDEX.md
+│   └── specs/
+│       └── _example.md
+└── (memory pattern docs — for reference; actual memory at ~/.claude/projects/.../memory/)
+```
+
+## Native features supported
+
+- ✅ Sub-agent dispatch (`Agent` tool with named persona).
+- ✅ Hooks (Stop, PreToolUse) for ABSOLUTE rule enforcement.
+- ✅ Lazy rule loading (`paths:` front-matter, glob-matched).
+- ✅ Per-call model routing (`model: "opus" | "sonnet" | "haiku"`).
+- ✅ Custom slash commands.
+- ✅ Built-in memory directory.
+- ✅ Always-loaded baseline (`CLAUDE.md`).
+
+## Features NOT supported (Claude limitations)
+
+None relevant to CONDUCTOR's scope. Claude is the reference implementation.
+
+## After install — first steps
+
+1. Edit `CLAUDE.md` — replace `{{PROJECT_NAME}}` and `{{DESIGN_SYSTEM_NAME}}` placeholders with your project's values.
+2. Review the generated `.claude/settings.json` (permissions allowlist + hooks registry). Customize hook paths if needed, or add per-user overrides in `.claude/settings.local.json`.
+3. Rename `docs/specs/_example.md` → `docs/specs/<your-area>.md` and start a real spec.
+4. Restart Claude Code in the project directory. Verify with `/help` that the new agents are recognized.
+5. Add your first entry to `docs/CURRENT_WORK.md`.
+
+## Quirks / known issues
+
+To be filled in `notes.md` after P1 real-install verification.
+
+## Status (P0 foundation)
+
+- ✅ `README.md` (this file)
+- ✅ `SUPPORTED-FEATURES.md`
+- ✅ `transform-spec.md`
+- ⏳ `transform.sh` (P1)
+- ⏳ `notes.md` (P1 — after first real verification)
+
+The v0.1 `install.sh` (under `archive/v0.1/`) provides equivalent output today and continues to work until the v0.2 Claude adapter ships in P1.

package/adapters/claude/SUPPORTED-FEATURES.md

@@ -0,0 +1,66 @@
+# Claude Code — supported features
+
+Detailed matrix of which CONDUCTOR features Claude Code supports natively.
+
+## Feature support
+
+| Feature | Claude support | Mechanism | Notes |
+|---|---|---|---|
+| **Sub-agent dispatch** | ✅ Native | `Agent` tool with `subagent_type` arg | Named personas live in `.claude/agents/*.md`. Each is isolated — does NOT inherit `CLAUDE.md`. |
+| **Per-call model routing** | ✅ Native | `model: "opus" \| "sonnet" \| "haiku"` arg on Agent call | Orchestrator classifies task → picks tier per call. |
+| **Hooks (PreToolUse, Stop, etc.)** | ✅ Native | `.claude/settings.json` `hooks:` block | Stop hooks are CONDUCTOR's spec-as-you-go enforcement. PreToolUse for routing. |
+| **Lazy rule loading** | ✅ Native | `paths:` front-matter on `.claude/rules/*.md` | Rule loads when matching file path is touched. |
+| **Always-loaded baseline** | ✅ Native | `CLAUDE.md` | Auto-read on every session start. Keep slim (~200 lines). |
+| **Custom slash commands** | ✅ Native | `.claude/commands/*.md` | Project-level commands available in chat (`/<command>`). |
+| **Skills (plugin ecosystem)** | ✅ Native | `Skill` tool + plugin marketplace | CONDUCTOR doesn't depend on skills, but is compatible. |
+| **MCP servers** | ✅ Native | `~/.claude/mcp.json` or project `.mcp.json` | CONDUCTOR doesn't ship MCP integration; projects can add their own. |
+| **Memory directory** | ✅ Native | `~/.claude/projects/<encoded>/memory/` | 4-type pattern: user / feedback / project / reference. |
+| **In-repo doc templates** | ✅ Native | Plain markdown under `docs/` | Read by orchestrator on demand. |
+| **Spec-as-you-go ABSOLUTE enforcement** | ✅ Stop hook | `stop-session-log-check.sh` blocks session-end if code commit is detected without spec update | Strongest CONDUCTOR feature. |
+| **Two-stage code review enforcement** | ✅ Stop hook | `stop-r6-review-check.sh` reminds about Stage A pre-commit + Stage B pre-merge PR | |
+| **Token economy enforcement** | ⚠️ Rule reminder | `meta-discipline.md` rule + agent self-discipline | No mechanical enforcement; relies on agent following the rule. |
+
+## Model tier mapping
+
+CONDUCTOR's universal `meta-discipline.md` rubric (token economy + model routing) maps directly to Claude's three tiers:
+
+| Universal tier | Claude model | Use cases |
+|---|---|---|
+| Opus | `claude-opus-4` (or current Opus equivalent) | Conceptual, multi-file, cross-cutting |
+| Sonnet | `claude-sonnet-4` (or current Sonnet equivalent) | Routine implementation following patterns |
+| Haiku | `claude-haiku-4` (or current Haiku equivalent) | Trivial reads / single-line edits |
+
+## 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`):
+
+| Hook | Event | Purpose |
+|---|---|---|
+| `pretool-agent-routing.sh` | `PreToolUse` (Agent calls) | Optionally remap or validate sub-agent dispatch (e.g., block `general-purpose` per CONDUCTOR R1). |
+| `pretool-commit-current-work-check.sh` | `PreToolUse` (Bash commit) | Block a commit if `CURRENT_WORK.md` was not updated alongside the change. |
+| `pretool-commit-test-coverage-check.sh` | `PreToolUse` (Bash commit) | Block a commit that adds code without matching test coverage. |
+| `pretool-large-file-read-guard.sh` | `PreToolUse` (Read) | Warn / guard against reading very large files wholesale (token economy). |
+| `stop-session-log-check.sh` | `Stop` | Block session end if code commits detected without matching spec update. |
+| `stop-r6-review-check.sh` | `Stop` (session end) | Inject reminder to run Stage B `/code-review` slash command if a feature/fix branch has open PR + cool-down. |
+| `stop-cache-hit-baseline-check.sh` | `Stop` | Flag prompt-cache baseline regressions at session end. |
+
+`transform.sh` registers all 7 in `.claude/settings.json` (4 `PreToolUse` + 3 `Stop`). Users customize paths and conditions in that generated file, or override per-user in `settings.local.json` (gitignored).
+
+## What Claude DOES NOT support that CONDUCTOR doesn't try to compensate for
+
+- Direct CI integration. Hooks run locally; CI is the project's responsibility.
+- IDE-style inline completion (Claude is a chat agent, not an IDE assistant — Cursor / Copilot fill that role).
+- Visual GUI for rule management (CLI / file-on-disk only).
+
+## Verification (P1 complete)
+
+The Claude adapter ships a working `transform.sh`. Verified by fresh-target install:
+
+| 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/` |
+| 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 |
+| 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/hookify-templates/.recipe-scoped

@@ -0,0 +1,9 @@
+# Recipe-scoped hookify templates (ADR-028).
+# Format: <template-basename-without-.template>  <recipe-name>
+# A template listed here is emitted by transform.sh ONLY when its recipe is in --recipes.
+# Templates NOT listed here are always-on (the default set).
+warn-create-table-without-access-control.local.md  database-discipline
+warn-security-definer-without-search-path.local.md  database-discipline
+warn-raw-hex-instead-of-token.local.md  design-system
+warn-hardcoded-text-without-i18n-key.local.md  i18n
+block-direct-push-protected-branch.local.md  branch-strategy

package/adapters/claude/hookify-templates/README.md

@@ -0,0 +1,93 @@
+# Hookify Rule Templates (Claude Code adapter)
+
+> Reusable hookify rule templates for Claude Code consumer projects. Hookify is a Claude Code plugin that intercepts events (Bash, file edits, prompts, stop) and injects warning/blocker messages based on YAML-frontmatter rules. These templates encode universal discipline patterns derived from production iteration in the originating reference project.
+
+## What this directory contains
+
+17 `.local.md.template` files. Each is a hookify rule with placeholders (`${CONDUCTOR_*}`) substituted at install time by `adapters/claude/transform.sh`. The output lands in the consumer project as `.claude/hookify.<name>.local.md`. Most are always-on; five are **recipe-scoped** (emitted only when their recipe is selected — see "Recipe-scoped templates" below).
+
+> **Branch-strategy disclaimer (2026-05-09)**: Direct-push to protected branches is **not** a universal pattern. Trunk-based projects routinely push to `main`. Multi-stage projects (e.g., `develop → release → main`) protect `main`/`release`. Because of this, direct-push blocking ships as an **opt-in** template (`block-direct-push-protected-branch`, recipe-scoped to `branch-strategy`) rather than always-on — adopters who want it select the `branch-strategy` recipe, and trunk-based projects simply omit it. Force-push protection (below) **is** universal — even trunk projects rarely want history rewrites — so it remains always-on.
+
+| Template | Event | Action | Universal trigger |
+|---|---|---|---|
+| `block-completion-claim-without-push` | stop | block | False completion claim before `git push` evidence |
+| `block-force-push-protected-branch` | bash | block | `git push --force origin <protected-branch>` |
+| `block-direct-push-protected-branch` | bash | block | Direct `git push` to a protected branch (recipe-scoped: branch-strategy) |
+| `warn-current-work-without-remaining-tasks` | file | warn | CURRENT_WORK edited without REMAINING_TASKS sync |
+| `warn-plan-spec-without-remaining-tasks` | file | warn | Plan/spec edited without cross-doc flip |
+| `warn-on-gh-pr-merge` | bash | warn | `gh pr merge` triggers 4-spot status flip |
+| `warn-stop-commit-without-current-work` | stop | warn | Session has commit but CURRENT_WORK not touched |
+| `warn-commit-without-pre-commit-review` | bash | warn | `git commit` without Q1 pre-commit review evidence |
+| `warn-gh-pr-create-without-pre-merge-review` | bash | warn | `gh pr create` triggers Q2 pre-merge review reminder |
+| `warn-user-manual-completion` | prompt | warn | User reports manual completion → docs-sync trigger |
+| `warn-any-type-added` | file | warn | TypeScript `: any` added (TS projects only) |
+| `warn-console-direct` | file | warn | Direct `console.error/log/warn` in production code |
+| `block-server-secret-in-client` | file | block | Server-only secret pattern added to a client-bundled file |
+| `warn-create-table-without-access-control` | file | warn | `CREATE TABLE` in a `.sql` file with no row-level access control in the same change (recipe-scoped: database-discipline) |
+| `warn-security-definer-without-search-path` | file | warn | `SECURITY DEFINER` function with no explicit `SET search_path` (recipe-scoped: database-discipline) |
+| `warn-raw-hex-instead-of-token` | file | warn | Inline raw hex color added to a `.tsx`/`.jsx`/`.css`/`.scss` file instead of a design token (recipe-scoped: design-system) |
+| `warn-hardcoded-text-without-i18n-key` | file | warn | Hardcoded user-facing string rendered in a component instead of a translation key (recipe-scoped: i18n) |
+
+## Recipe-scoped templates
+
+Most templates above are **always-on**: every install emits them. Five are **recipe-scoped** — they emit only when the matching recipe is passed via `--recipes`. The mapping lives in the `.recipe-scoped` file in this directory (basename → recipe):
+
+```
+warn-create-table-without-access-control.local.md  database-discipline
+warn-security-definer-without-search-path.local.md  database-discipline
+warn-raw-hex-instead-of-token.local.md  design-system
+warn-hardcoded-text-without-i18n-key.local.md  i18n
+block-direct-push-protected-branch.local.md  branch-strategy
+```
+
+The SQL rules above are stack-shaped (they only make sense for projects with a relational store), so shipping them always-on would inject SQL-specific noise into projects that have no SQL. The same logic applies to the UI-shaped rules: `warn-raw-hex-instead-of-token` only matters where a design-token system exists, and `warn-hardcoded-text-without-i18n-key` only matters on multi-locale projects. Gating each behind its recipe (`design-system`, `i18n`) keeps the always-on set vendor- and stack-neutral while still letting stack-shaped rules ship opt-in.
+
+`transform.sh` Step 4.5 consults `.recipe-scoped`: a listed template is skipped unless its recipe is in `--recipes`; a template NOT listed is always emitted. Lines beginning with `#` are comments. See `docs/DESIGN-DECISIONS.md` ADR-028.
+
+## Placeholder reference
+
+These tokens are substituted by `transform.sh` `substitute_template()`:
+
+| Placeholder | Default | Override |
+|---|---|---|
+| `${CONDUCTOR_PROTECTED_BRANCHES}` | `main\|release` | env `CONDUCTOR_PROTECTED_BRANCHES` (alternation regex) |
+| `${CONDUCTOR_CURRENT_WORK_PATH}` | `docs/CURRENT_WORK.md` | env `CONDUCTOR_CURRENT_WORK_PATH` |
+| `${CONDUCTOR_REMAINING_TASKS_PATH}` | `docs/REMAINING_TASKS.md` | env `CONDUCTOR_REMAINING_TASKS_PATH` |
+| `${CONDUCTOR_SOURCE_GLOB}` | `apps/.*\\.(ts\|tsx)$` | env `CONDUCTOR_SOURCE_GLOB` |
+| `${CONDUCTOR_CLIENT_GLOB}` | `(src/(components\|hooks\|pages\|ui)\|public)/.*\\.(ts\|tsx\|js\|jsx)$` | env `CONDUCTOR_CLIENT_GLOB` (client-bundled paths; lookahead-free) |
+| `${CONDUCTOR_SERVER_SECRET_PATTERN}` | `(SERVICE_ROLE_KEY\|SERVICE_ROLE\|_SECRET_KEY\|_PRIVATE_KEY\|ADMIN_API_KEY\|SECRET_ACCESS_KEY)` | env `CONDUCTOR_SERVER_SECRET_PATTERN` (generic credential env-var name shapes, not a vendor reference) |
+| `${CONDUCTOR_PROJECT_NAME}` | `your-project` | env `CONDUCTOR_PROJECT_NAME` |
+
+If an adopter project doesn't use a particular convention (e.g., no `docs/REMAINING_TASKS.md`), the relevant rule body should be edited or the file deleted post-install. Templates are scaffolding, not enforcement.
+
+## Install / update
+
+Run via the Claude adapter:
+
+```bash
+bash adapters/claude/transform.sh <target-project> [--recipes=...]
+```
+
+Step 4.5 of the pipeline copies these templates to `<target>/.claude/hookify.<name>.local.md` with placeholders substituted. Existing files in `<target>/.claude/hookify.*` are NOT overwritten — adopter customizations win.
+
+## Adopting / removing individual rules
+
+After install, every emitted file has `enabled: true` in frontmatter. To disable a rule without deleting it, flip to `enabled: false`. To delete entirely, remove the file. Adopters MAY add their own `hookify.<custom-name>.local.md` — the framework-emitted templates are namespaced clearly enough to coexist (no collisions expected, but check before adding).
+
+## Why hookify-only (no Cursor / Copilot equivalent)
+
+Hookify is a Claude Code plugin. Cursor uses MDC files with separate semantics. Copilot uses repository instructions without runtime intercept. If those tools add comparable runtime hook plugins, equivalent templates land under their respective adapter (`adapters/cursor/`, `adapters/copilot/`).
+
+## Originating reference project
+
+Patterns abstracted from production iteration. Each template body cites the universal rule it enforces (`workflow.md`, `quality-gates.md`, `spec-as-you-go.md`) — NOT vendor-specific stack rules. Vendor-specific rules (database row-level-security policies, transactional-email header conventions, UI-library / icon-pack banlists, design-token enforcement, multi-platform parity) are intentionally out of scope: they belong in the adopter project as project-local hookify files, not in framework templates.
+
+**Refinement (ADR-027)**: the original port boundary (ADR-018) placed "service-role key in client" entirely out of scope as a vendor-specific literal. That boundary is now refined. The *vendor literal* (a specific key name) stays project-local — but the *generalized server-secret-leak pattern* (any server-only credential-shaped name appearing in a client-bundled path) is a universal security hazard, not a stack specific. It now ships as `block-server-secret-in-client` with overridable `${CONDUCTOR_CLIENT_GLOB}` and `${CONDUCTOR_SERVER_SECRET_PATTERN}` placeholders (the latter defaults to generic credential env-var name shapes, never a vendor product name). See ADR-027.
+
+## Related
+
+- `adapters/claude/transform.sh` — installer
+- `adapters/claude/SUPPORTED-FEATURES.md` — Claude adapter feature matrix
+- `core/universal-rules/workflow.md`, `quality-gates.md`, `spec-as-you-go.md` — the rule bodies these templates enforce
+- `docs/DESIGN-DECISIONS.md` ADR-018 — port boundary decision
+- `docs/DESIGN-DECISIONS.md` ADR-027 — generalized server-secret-leak pattern carved back in (refines ADR-018)

package/adapters/claude/hookify-templates/block-completion-claim-without-push.local.md.template

@@ -0,0 +1,56 @@
+---
+name: block-completion-claim-without-push
+enabled: true
+event: stop
+action: block
+conditions:
+  - field: transcript
+    operator: regex_match
+    pattern: ✅\s*(완료|DONE|SHIPPED|done|shipped)|(?:Task|Phase|PR)\s*#?\d+\s*(완료|done|shipped|✅)|구현\s*완료|개발\s*완료|기능\s*완료|implementation\s+complete|feature\s+complete
+  - field: transcript
+    operator: not_contains
+    pattern: git push origin
+---
+
+🚨 **Verify before completion claim — completion declared without `git push` evidence**
+
+The session transcript contains a completion claim ("✅ DONE / SHIPPED / 완료 / implementation complete / feature complete") but no `git push origin` trace.
+
+This rule enforces the **verification-before-completion** principle from `core/universal-rules/quality-gates.md` Q4. False completion claims are the highest-friction failure mode — they cascade into stale documentation, wasted next-session investigation time, and broken downstream work.
+
+### Required evidence checklist
+
+**1. Code / docs change evidence**:
+```bash
+git status --short                          # uncommitted = incomplete
+git log --oneline origin/<branch>..HEAD     # local-only commit?
+```
+
+**2. If the claim concerns features / implementation**:
+- Read the relevant file(s) and confirm the implementation lines exist.
+- Confirm test PASS output (e.g., test runner exit 0).
+- Confirm spec frontmatter `last-updated` and body sections were updated (per `core/universal-rules/spec-as-you-go.md`).
+
+**3. If the claim concerns a PR merge**:
+- `gh pr view <#> --json mergedAt,state` actually verified.
+- `git log origin/<branch>` contains the merge sha.
+
+**4. Cross-doc flip** (per `core/universal-rules/spec-as-you-go.md` §3 same-turn rule):
+- `${CONDUCTOR_REMAINING_TASKS_PATH}` task item closed.
+- `${CONDUCTOR_CURRENT_WORK_PATH}` `+N` entry appended.
+- The relevant plan/spec frontmatter status flipped (e.g., `APPROVED → SHIPPED`).
+- Any related runbook checklists closed.
+
+### Stop-gate decision
+
+- All four pieces of evidence verified → run `git push origin <branch>` then Stop.
+- Work is in progress → restate as "in progress / partially complete / blocked on X" and Stop.
+- Some items false-claimed → retract the claim and report accurate state.
+
+### Refresh logic (loop prevention)
+
+Once `git push origin` appears in the transcript at least once, this rule no longer fires (the work has actually been pushed). The goal is to block the *first* false claim within a single session.
+
+### Project-local note
+
+If `${CONDUCTOR_PROJECT_NAME}` does not use `git push origin` as the canonical "shipped" signal (e.g., trunk-based with direct deploy from CI artifact), edit this rule body's "evidence" section to match the actual shipped signal. Do NOT delete the rule outright — the underlying principle (verify-before-claim) is universal.

package/adapters/claude/hookify-templates/block-direct-push-protected-branch.local.md.template

@@ -0,0 +1,18 @@
+---
+name: block-direct-push-protected-branch
+enabled: true
+event: bash
+action: block
+conditions:
+  - field: command
+    operator: regex_match
+    pattern: git\s+push\b.*\b(${CONDUCTOR_PROTECTED_BRANCHES})\b
+---
+
+🚫 **Direct push to a protected branch (blocked)**
+
+A direct `git push` to a protected branch (`${CONDUCTOR_PROTECTED_BRANCHES}`) was attempted. Open a PR and merge through review instead.
+
+If your project is trunk-based and pushes to its mainline by design, this rule should not be installed — remove it or do not select the `branch-strategy` recipe.
+
+**block — operation halted. Push to a feature branch and open a PR.**

package/adapters/claude/hookify-templates/block-force-push-protected-branch.local.md.template

@@ -0,0 +1,42 @@
+---
+name: block-force-push-protected-branch
+enabled: true
+event: bash
+action: block
+conditions:
+  - field: command
+    operator: regex_match
+    pattern: \bgit\s+push\b.*(?:--force\b|--force-with-lease\b|-f\b).*\borigin\s+(${CONDUCTOR_PROTECTED_BRANCHES})\b
+---
+
+🚨 **Protected-branch force push blocked**
+
+`git push --force` (or `--force-with-lease` / `-f`) targeting `origin (${CONDUCTOR_PROTECTED_BRANCHES})` detected. **Forbidden operation** per `core/recipes/branch-strategy.md`.
+
+### Why force push to protected branches is dangerous
+
+- `--force` overwrites remote history — every collaborator's commit on top of the prior tip is lost or orphaned.
+- `--force-with-lease` is safer in spirit but still race-prone: a fetch immediately before push satisfies the lease while another collaborator's just-pushed work is lost.
+- Auto-deploy branches force-pushed mid-deploy can produce a half-deployed system (CDN cached old, origin holds new, etc.).
+- Audit trails break: bisects past the rewrite point fail, blame loses authorship continuity.
+
+### Recovery / alternative workflow
+
+If the goal was to remove a bad commit from a protected branch:
+
+```bash
+# Revert via additional commit (preserves history)
+git checkout -b <branch>-revert-<topic>
+git revert <bad-commit>             # or cherry-pick a fix commit
+gh pr create --base <protected> --head <branch>-revert-<topic>
+```
+
+### Explicit user override
+
+The framework's branch-strategy recipe records that on **non-protected** branches (feature / fix / chore branches), force push may be the user's preference (faster than rebasing carefully). On protected branches, it is never acceptable without an incident-response justification.
+
+### Project-local note
+
+`${CONDUCTOR_PROTECTED_BRANCHES}` is an alternation regex matching your project's protected branches. If you have GitHub branch protection rules enforcing the same constraint server-side, this rule provides the client-side early stop (faster feedback than waiting for the server reject).
+
+**Block — operation halted. Use revert-via-PR workflow and retry.**