lgtm-specs 0.0.4

package/.claude/settings.local.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(grep:*)",
+      "WebSearch",
+      "WebFetch(domain:opencode.ai)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:models.dev)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(gh api:*)",
+      "WebFetch(domain:docs.claude.com)"
+    ]
+  }
+}

package/.gemini/README.md

@@ -0,0 +1,8 @@
+# Gemini Review
+
+This directory configures Gemini-based code review tools.
+
+## Index
+
+- `styleguide.md`: Review guidance for this repository.
+- `config.yaml`: Focus areas and include/exclude patterns.

package/.gemini/config.yaml

@@ -0,0 +1,20 @@
+review_focus:
+  - correctness
+  - maintainability
+  - security
+  - documentation
+
+include_patterns:
+  - "AGENTS.md"
+  - "README.md"
+  - "VERSION"
+  - "agents/**"
+  - "contribute/**"
+  - "docs/**"
+  - "integrate/**"
+  - "models/**"
+  - "rules/**"
+  - "scripts/**"
+
+exclude_patterns:
+  - "ideas/**"

package/.gemini/styleguide.md

@@ -0,0 +1,35 @@
+# Code Review Style Guide (lgtm-specs)
+
+This repository is a specification Knowledge Graph. Review changes as **spec edits**, not application code.
+
+## Review Focus
+
+1.  **Integrity**
+    - Links are repo-relative and targets exist.
+    - New directories have an index `README.md`.
+    - New nodes are indexed in the correct parent index.
+
+    Reference: [Definition of Done](../contribute/checklist.md).
+
+2.  **Rule Template Compliance** (`rules/`)
+    - Each atomic rule has: `Source`, `Tags`, `Related`.
+    - Contains: Definition, Requirements, Anti-Patterns, Examples.
+    - Examples include both **Bad** and **Good** snippets.
+
+    Reference: [Rule Template](../rules/RULE-00000-EXAMPLE.md) and [Definition of Done](../contribute/checklist.md).
+
+3.  **Agent Contracts** (`agents/`, `integrate/`)
+    - Do not break placeholder contracts (e.g., `{{injected_rules}}`).
+    - Model capability IDs must match `models/registry.yaml` keys.
+
+    Reference: [Integration Protocol](../integrate/README.md).
+
+4.  **Noise Control**
+    - Report only current issues.
+    - Do not state "fixed", "resolved", or "already addressed".
+    - Prefer concrete, actionable findings.
+
+## Output Format
+
+- Use a short list of issues.
+- Each issue includes the file path and what to change.

package/.github/workflows/README.md

@@ -0,0 +1,5 @@
+# Workflows
+
+## Index
+
+- `validate.yml`: Runs repository validation checks.

package/.github/workflows/release.yml

@@ -0,0 +1,52 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Bun check
+        run: bun run check
+
+      - name: Verify tag matches VERSION
+        shell: bash
+        run: |
+          set -euo pipefail
+          ver="$(cat VERSION)"
+          tag="${GITHUB_REF_NAME}"
+          if [[ "v${ver}" != "${tag}" ]]; then
+            echo "ERROR: Tag ${tag} does not match VERSION ${ver}" >&2
+            exit 1
+          fi
+
+      - name: Generate release notes
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: python3 scripts/generate_release_notes.py --output release-notes.md
+
+      - name: Create GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: release-notes.md

package/.github/workflows/validate.yml

@@ -0,0 +1,27 @@
+name: Validate Specs
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Bun check
+        run: bun run check

package/.prettierignore

@@ -0,0 +1,4 @@
+.git/
+ideas/
+tmp/
+.temp/

package/.prettierrc

@@ -0,0 +1 @@
+{}

package/AGENTS.md

@@ -0,0 +1,151 @@
+# Agent Instructions (lgtm-specs)
+
+This repository (`lgtm-specs`) is a versioned **Knowledge Graph** of specs (rules + agent prompts). Treat changes as spec
+edits, not application code.
+
+Repo-local assistant instructions:
+
+- Cursor: none (`.cursor/rules/` and `.cursorrules` do not exist)
+- Copilot: none (`.github/copilot-instructions.md` does not exist)
+- Gemini review tooling: see `.gemini/styleguide.md` (optional)
+
+## 1. Build / Lint / Test
+
+CI parity (recommended):
+
+```bash
+bun run check
+```
+
+What this runs:
+
+```bash
+# Validation (graph structure, indexing, capability registry, VERSION sync)
+bun run validate
+# or:
+python3 scripts/validate_specs.py
+
+# Formatting (Prettier)
+bun run format
+bun run format:check
+```
+
+Single-file "test" (fast feedback):
+
+```bash
+FILE="rules/constitution/CONS-00027-transparency.md"
+
+# Format only this file
+bunx prettier --check "$FILE"
+bunx prettier --write "$FILE"
+
+# Minimal structure checks (exists, indexed, required headers/keys)
+test -f "$FILE" && echo "OK: exists"
+grep -q "$(basename "$FILE")" "$(dirname "$FILE")/README.md" && echo "OK: indexed"
+
+for key in Source Tags Related; do
+  grep -q "^\\*\\*$key\\*\\*:" "$FILE" && echo "OK: $key"
+done
+
+for hdr in "## Definition" "## Requirements" "## Anti-Patterns" "## Examples"; do
+  grep -q "$hdr" "$FILE" && echo "OK: $hdr"
+done
+
+for ex in Bad Good; do
+  grep -q "\\*\\*$ex:\\*\\*" "$FILE" && echo "OK: $ex example"
+done
+```
+
+Optional (network-dependent) external URL validation:
+
+```bash
+python3 scripts/validate_specs.py --check-urls
+python3 scripts/validate_specs.py --check-urls --url-timeout 12
+python3 scripts/validate_specs.py --check-urls --url-ignore "https://example.com/badge.svg"
+```
+
+Optional warnings baseline (temporary migrations only):
+
+```bash
+python3 scripts/validate_specs.py --write-baseline scripts/validate_baseline.txt
+python3 scripts/validate_specs.py --baseline scripts/validate_baseline.txt
+```
+
+ID collision check:
+
+```bash
+git grep -n "CONS-00033" || echo "ID available"
+```
+
+## 2. Code Style Guidelines
+
+### 2.1 Specs (Markdown)
+
+Naming:
+
+- Constitution: `rules/constitution/CONS-00000-slug.md`
+- Laws: `rules/laws/<domain>/<DOMAIN>-00000-slug.md` (e.g., `GO-00000-...md`, `TS-00000-...md`)
+- Policies: `rules/policies/default.md` or `rules/policies/<project>-policy.md`
+
+Atomic rule requirements (see `rules/RULE-00000-EXAMPLE.md`):
+
+- H1 title: `# Name (ID)`
+- Metadata lines: `**Source**:`, `**Tags**:`, `**Related**:`
+- Sections: `## Definition`, `## Requirements`, `## Anti-Patterns`, `## Examples`
+- Examples: both `**Bad:**` and `**Good:**` (multi-line; prefer fenced blocks)
+
+Citations and links:
+
+- Source-of-truth material lives in `docs/meta/**`; do not invent citations.
+- Use repo-root-relative links (`/rules/...`, `/docs/...`) and ensure targets exist.
+- `**Source**` links into `docs/meta/**` should include an anchor (`#...`).
+
+Tags and writing:
+
+- Include at least one dimension tag: `#structural`, `#behavioral`, `#runtime`, `#operational`.
+- Keep specs skimmable; avoid filler; keep lines <= 120 chars.
+- Run `bun run format` before finalizing Markdown edits.
+
+Indexing:
+
+- Every directory with content MUST have a `README.md` indexing its files.
+- Any new file must be added to the parent directory index `README.md`.
+
+### 2.2 Agent Specs (`agents/**`)
+
+Contracts (external tools parse these; see `integrate/README.md`):
+
+- Do not remove placeholders like `{{injected_rules}}` / `{{indices}}`.
+- Modes require: `<Meta>`, `<Role>`, `<Workflow>`.
+- Roles require: `<Meta>`, `<Role>`, `<Input>`, `<Objective>`, `<OutputFormat>`, `<Workflow>`.
+- `<Meta>` key lines must start at column 1; role specs must include `Capability: <id>`.
+- `Capability` must exist as a key in `models/registry.yaml`.
+
+Valid capability IDs: `reasoning`, `coding`, `data`, `fast`, `security`, `docs`, `general`.
+
+### 2.3 Python Tooling (`scripts/**/*.py`)
+
+- Dependencies: standard library only; keep CI-compatible (Python 3.11+).
+- Imports: `from __future__ import annotations` first; then stdlib imports, grouped and alphabetized.
+- Types: annotate public functions; prefer builtin generics (`list[str]`, `dict[str, ...]`).
+- Naming: `snake_case` (func/var), `PascalCase` (class), `SCREAMING_SNAKE_CASE` (constants).
+- Error handling: print failures to stderr; return non-zero exit codes; keep messages deterministic.
+- Determinism: stable ordering (sort sets/dicts); avoid timestamps/randomness unless required.
+
+## 3. Definition of Done
+
+- `bun run check` passes (validator + prettier check).
+- IDs are unique (use `git grep -n "<ID>"`).
+- New/changed files are indexed (parent `README.md` updated).
+- Rule files include required metadata/sections and both Bad/Good examples.
+- Internal links resolve; `**Source**` links into `docs/meta/**` include anchors.
+- Integration changes preserve placeholders and keep `VERSION` in sync with `integrate/README.md`.
+
+## 4. Handy Commands
+
+```bash
+git status && git diff --name-only
+git log -n 20 --oneline
+git grep -l "error handling" rules/
+ls rules/constitution/CONS-*.md
+```

package/README.md

@@ -0,0 +1,98 @@
+# LGTM Specifications
+
+[![Validate Specs](https://github.com/yyforyongyu/lgtm-specs/actions/workflows/validate.yml/badge.svg?branch=main)](https://github.com/yyforyongyu/lgtm-specs/actions/workflows/validate.yml?query=branch%3Amain) [![Version](https://img.shields.io/github/v/tag/yyforyongyu/lgtm-specs?sort=semver)](https://github.com/yyforyongyu/lgtm-specs/releases)
+
+LGTM Specifications is a versioned knowledge graph of engineering standards (Rules) and an autonomous workforce (Agents) used by tools to plan, build, and audit changes with high assurance.
+
+## Knowledge
+
+We turn industry best practices and internal standards into atomic, enforceable rules:
+
+1. Source material lives in `docs/meta/**`.
+2. Atomic rules live in `rules/**` and cite their sources.
+3. Runtimes inject only the relevant rules for a given task (tag/domain based) instead of loading the entire graph.
+
+Start here:
+
+- [Rules Index](rules/README.md)
+- [Docs Index](docs/README.md)
+
+## Workflows
+
+LGTM runs as a set of operating modes that orchestrate a specialist team (Lead, Explorer, Counsel, Planner, Builder, Reviewer panel).
+
+Modes:
+
+- `@Build`: production changes (rules + plan + proof + specialist review).
+- `@Hack`: fast iteration (lighter gates).
+- `@Review`: read-only audit.
+
+Core roles:
+
+- Lead orchestrates and arbitrates.
+- Explorer maps the target repo.
+- Counsel selects minimal relevant rule paths.
+- Planner produces an execution/audit plan.
+- Builder implements and produces proof.
+- Reviewers audit from specialized perspectives.
+
+Start here:
+
+- [Agent Architecture](docs/agent_architecture.md)
+- [Agents Index](agents/README.md)
+
+## Integrating
+
+Tools consume this repo as a read-only spec database.
+
+Start here:
+
+- [Integration Protocol](integrate/README.md)
+
+Copy/paste prompt for a tool/LLM implementing the integration:
+
+```text
+You are implementing integration for the LGTM specs repo (yyforyongyu/lgtm-specs).
+
+Goal: wire this repo into a coding tool so it can run the LGTM agent workflows.
+
+Read and follow `integrate/README.md` exactly, including:
+- Parsing `agents/**/*.md` and honoring placeholders like `{{injected_rules}}`.
+- Running Counsel and enforcing its JSON output schema.
+- Hydrating rule paths into rule content and injecting role-appropriate subsets per reviewer.
+- Resolving models using `models/registry.yaml` in list order (preference order) with deterministic availability checks.
+
+Output:
+1) a concise implementation checklist,
+2) the minimal data structures you will use (schemas),
+3) pseudocode for: index loading -> counsel -> rule hydration -> per-agent injection -> execution.
+```
+
+## Contributing
+
+Contributions should preserve atomicity, indexing, and link integrity.
+
+Start here:
+
+- [Contribution Guide](contribute/README.md)
+- [Definition of Done Checklist](contribute/checklist.md)
+- Local checks: `bun run check` (runs spec validation + `prettier --check`).
+
+Copy/paste prompt for an LLM starting a contribution:
+
+```text
+You are contributing to the LGTM specs repo (yyforyongyu/lgtm-specs).
+
+Read `contribute/README.md` and `contribute/checklist.md` and follow them strictly.
+Run `bun run check` before finalizing your changes.
+
+Constraints:
+- One rule per file; follow the rule template used in this repo.
+- Add new files to the parent directory index README(s).
+- Use repo-relative links only and ensure every link target exists.
+
+Task:
+1) identify the smallest set of atomic rule/doc changes needed for the request,
+2) propose exact file edits,
+3) run `python3 scripts/validate_specs.py` and report any failures.
+```

package/VERSION

@@ -0,0 +1 @@
+0.0.4

package/agents/README.md

@@ -0,0 +1,73 @@
+# Agent Workforce
+
+This directory defines the LGTM agent contracts:
+
+- Modes (workflows): `@Build`, `@Hack`, `@Review`
+- Roles (workers): `@Lead`, `@Planner`, `@Counsel`, `@Builder`, `@Explorer`, `@Librarian`, `@Reviewer*`
+
+Files under `agents/` are runtime-consumed contracts optimized for parsing and prompt injection.
+For a human-facing overview, see [Agent Architecture](../docs/agent_architecture.md).
+
+## Operating Modes
+
+- [@Build](modes/build.md): Production engineering; strict planning + verification + consensus gates.
+- [@Hack](modes/hack.md): Rapid prototyping; lighter gates; produce a draft branch/PR.
+- [@Review](modes/review.md): Read-only audit; produce an evidence-backed report.
+
+## Roles
+
+- [@Lead](roles/lead.md): Orchestrator and arbitrator.
+- [@Planner](roles/planner.md): Execution/audit plan author.
+- [@Counsel](roles/counsel.md): Rule/policy selection (paths + reasons).
+- [@Explorer](roles/explorer.md): Codebase mapping and policy discovery (Context Map).
+- [@Builder](roles/builder.md): Implementation + required proof (inner loop).
+- [@Librarian](roles/librarian.md): External documentation/spec research with citations.
+
+## Review Panel
+
+- [@Reviewer](roles/reviewer/README.md): Panel index (specialists).
+- [@Plan-Reviewer](roles/reviewer/plan.md): Plan critique (feasibility/alignment).
+- [@Reviewer-Lite](roles/reviewer/lite.md): Atomic diff sanity gate (fast).
+- [@Reviewer-Logic](roles/reviewer/logic.md): Correctness audit.
+- [@Reviewer-Quality](roles/reviewer/quality.md): Maintainability + docs audit.
+- [@Reviewer-Test](roles/reviewer/test.md): Test coverage + rigor audit.
+- [@Reviewer-Security](roles/reviewer/security.md): Trust boundary + safety audit.
+- [@Reviewer-Performance](roles/reviewer/performance.md): Efficiency + resource usage audit.
+
+## Templates (For Maintainers)
+
+- Role template: [templates/role.md](templates/role.md)
+- Mode template: [templates/mode.md](templates/mode.md)
+
+## Directory Structure
+
+```text
+agents/
+├── modes/
+│   ├── README.md
+│   ├── build.md
+│   ├── hack.md
+│   └── review.md
+├── templates/
+│   ├── README.md
+│   ├── role.md
+│   └── mode.md
+└── roles/
+    ├── lead.md
+    ├── planner.md
+    ├── counsel.md
+    ├── explorer.md
+    ├── builder.md
+    ├── librarian.md
+    └── reviewer/
+        ├── BASE.md
+        ├── OUTPUT_FORMAT.md
+        ├── README.md
+        ├── plan.md
+        ├── lite.md
+        ├── logic.md
+        ├── quality.md
+        ├── security.md
+        ├── performance.md
+        └── test.md
+```

package/agents/modes/README.md

@@ -0,0 +1,9 @@
+# Operating Modes
+
+Mode specs define the canonical orchestration workflows for the LGTM workforce.
+
+## Index
+
+- [@Build](build.md): High-assurance engineering workflow.
+- [@Hack](hack.md): Rapid prototyping workflow.
+- [@Review](review.md): Read-only audit workflow.

package/agents/modes/build.md

@@ -0,0 +1,88 @@
+# Mode: @Build
+
+<Meta>
+Type: High-Assurance Engineering Workflow.
+Brain: Uses **[@Lead](../roles/lead.md)** for arbitration and orchestration decisions.
+
+Trigger:
+
+- New Feature implementation.
+- Refactoring critical paths (Auth, Payments, Cryptography).
+- Public API changes.
+- Database Schema migrations.
+- "Production Ready" work.
+
+Team:
+
+- **Manager**: **[@Lead](../roles/lead.md)**.
+- **Architect**: **[@Planner](../roles/planner.md)**.
+- **Compliance**: **[@Counsel](../roles/counsel.md)**.
+- **Researcher**: **[@Librarian](../roles/librarian.md)** (Optional).
+- **Maker**: **[@Builder](../roles/builder.md)**.
+- **Cartographer**: **[@Explorer](../roles/explorer.md)**.
+- **Plan Reviewer**: **[@Plan-Reviewer](../roles/reviewer/plan.md)**.
+- **Micro-Critic**: **[@Reviewer-Lite](../roles/reviewer/lite.md)**.
+- **Critics**: **[@Reviewer](../roles/reviewer/README.md)** (Panel).
+</Meta>
+
+<Role>
+**Goal**: Ship Features, Refactors, and Production Code.
+</Role>
+
+<Workflow>
+## Phase 1: Clarify & Design (The Blueprint)
+1.  **Orchestrate**: `@Lead` assesses the request and engages `@Explorer` to map the codebase.
+2.  **Compliance**: `@Lead` consults `@Counsel` for Rules and Policies.
+    *   **Inject**: `@Lead` instructs the Runtime to load/hydrate rule content and inject `{{injected_rules}}` into
+        `@Planner` and all reviewers used in this mode (`@Plan-Reviewer`, `@Reviewer-Lite`, Panel).
+3.  **Draft**: `@Planner` creates the **Execution Plan**.
+    *   *Input*: User Request + Map + Rules.
+4.  **Plan Review**: Call **two** independent `@Plan-Reviewer` instances.
+    *   *Gate*: Must have unanimous approval to proceed.
+    *   *Loop*: Max 3 revision cycles.
+    *   *Timeout*: 5 minutes per reviewer per cycle (default; runtime may override).
+    *   *On Timeout*: Re-assign each timed-out reviewer once. If it still times out, treat as a reject for that cycle.
+    *   *On Reject*: `@Lead` digests reviewer feedback, decides legitimacy, and asks `@Planner` to revise the plan.
+    *   *After Max*: If still not unanimously approved after 3 cycles, `@Lead` must either abort (recommended) or
+        arbitrate/override by authoring a revised plan with an explicit risk rationale.
+5.  **Gate**: Present Plan to User. **WAIT for Sign-off**.
+    *   *Constraint*: Do not proceed to Build until Plan is explicitly approved.
+
+## Phase 2: Execute (The Heavy Loop)
+
+For each Task in the Plan:
+
+1.  **Build**: Call `@Builder` with `(Task, Rules, Verification)`.
+    - _Constraint_: Verification is mandatory. The proof level is defined per step (tests and/or other evidence).
+2.  **Micro-Audit**: Call `@Reviewer-Lite` on the diff.
+    - _Scope_: Fast sanity gate (obvious correctness breakage + basic style/tooling + commit message); deep specialist review happens in Phase 3.
+    - _Input_: Include the PR merge target as `Base Ref` and the atomic `Commit Message` when available.
+    - _Retry_: Max 3 attempts.
+    - _Timeout_: 5 minutes per attempt.
+    - _On Timeout_: Treat as a reject and retry.
+    - _On Reject_: `@Lead` digests feedback, decides legitimacy, and asks `@Builder` to address it.
+    - _Fail_: If 3 retries fail, `@Lead` calls `@Planner` to re-plan or overrides with rationale.
+
+## Phase 3: Consensus (The Jury)
+
+1.  **Verify**: Ensure required verification passes (including integration tests when required).
+2.  **Audit**: Call the **Full Review Panel**.
+    - Mandatory: `Logic`, `Quality`, `Test`.
+    - Conditional: `Security` (if tagged), `Performance` (if tagged).
+3.  **Gate**: Unanimous Approval Required.
+    - _Loop_: Max 10 review->fix cycles.
+    - _Timeout_: 10 minutes per reviewer per cycle.
+    - _On Timeout_: Re-assign each timed-out reviewer once. If it still times out, treat as a reject for that cycle.
+    - _Clarify_: If a finding is contested or unclear, `@Lead` asks the specific reviewer to justify or withdraw it (one round-trip max) before planning fixes.
+    - _Cycle_: On each rejection, `@Lead` digests the panel feedback and calls `@Planner` to produce a remediation todo list. `@Builder` executes tasks one at a time, then the panel re-reviews.
+    - _Compress_: After each cycle, keep a compact "Resolved / Remaining" summary; do not carry full prior transcripts into later cycles.
+    - _Arbitration (Conditional)_: If reviewers deadlock/contradict, runtime injects the minimum Tier 2 contested diff and
+      full contested rules into `@Lead`; `@Lead` judges citing rule IDs and diff evidence.
+    - _Override_: If needed, `@Lead` may override with an explicit risk rationale.
+    - _After Max_: If still not unanimous after 10 cycles, `@Lead` must either abort (recommended) or override with an explicit risk rationale.
+
+## Phase 4: Delivery
+
+- **Finalize**: Produce the Production-Ready PR.
+
+</Workflow>

package/agents/modes/hack.md

@@ -0,0 +1,76 @@
+# Mode: @Hack
+
+<Meta>
+Type: Rapid Prototyping Workflow.
+Brain: Uses **[@Lead](../roles/lead.md)** for orchestration.
+
+Trigger:
+
+- "Try this idea out".
+- "Quick prototype".
+- Single-file logic patches (non-critical).
+- UI/Text tweaks.
+- Documentation updates.
+
+SafetyProfile:
+Do not auto-escalate or switch modes; run `@Hack` as selected.
+
+Critical-path heuristics (informational only)
+
+- Authentication / Authorization (auth, login, permissions)
+- Billing / Payments / Ledger
+- Cryptography / Secrets
+- Database Schema (migrations, schema files)
+- Public API Contracts
+
+Team:
+
+- **Manager**: **[@Lead](../roles/lead.md)** (Gatekeeper).
+- **Cartographer**: **[@Explorer](../roles/explorer.md)**.
+- **Compliance**: **[@Counsel](../roles/counsel.md)** (Optional).
+- **Researcher**: **[@Librarian](../roles/librarian.md)** (Optional).
+- **Architect**: **[@Planner](../roles/planner.md)** (Sketch/Plan).
+- **Maker**: **[@Builder](../roles/builder.md)** (Fast Mode).
+- **Plan Reviewer**: **[@Plan-Reviewer](../roles/reviewer/plan.md)** (Optional).
+- **Critic**: **[@Reviewer-Lite](../roles/reviewer/lite.md)**.
+</Meta>
+
+<Role>
+**Goal**: PoCs, Experiments, Non-Critical Fixes.
+</Role>
+
+<Workflow>
+## Phase 1: Sketch
+1.  **Map**: `@Lead` engages `@Explorer` to identify likely touched files and risks.
+2.  **Plan**: `@Planner` creates a short "Sketch Plan" (atomic steps + files).
+3.  **Rules (Optional)**: If the user requests stricter compliance, `@Lead` consults `@Counsel` and instructs the Runtime
+    to hydrate and inject `{{injected_rules}}`.
+4.  **Plan Review**: Optional. `@Lead` may call `@Plan-Reviewer` (0-1) based on scope (e.g., multi-step/multi-file) or
+    if the user requests it.
+    *   *Timeout (Default)*: 5 minutes if called.
+    *   *On Timeout*: Proceed without plan review.
+
+## Phase 2: Code (The Fast Loop)
+
+1.  **Build**: Call `@Builder`.
+    - _Constraint_: No mandatory TDD or Unit Tests in `@Hack`.
+    - _Note_: If the user requests tests, include them in the plan.
+2.  **Check**: Call `@Reviewer-Lite` (Format + Basic Logic).
+    - _Scope_: Sanity checks only (no deep architecture review).
+    - _Input_: Pass the PR merge target as `Base Ref` and the atomic `Commit Message` when available.
+    - _If REJECT_: `@Lead` digests feedback and asks `@Builder` to address it.
+    - _Retry_: Max 3 attempts.
+    - _Timeout_: 5 minutes per attempt.
+    - _Fail_: If 3 retries fail, `@Lead` decides to proceed (as a prototype) or abort.
+
+## Phase 3: Delivery
+
+- **Finalize**: Produce a Draft PR or Experimental Branch.
+- **Note**: Explicitly label as "Prototype / Not Production Ready".
+
+</Workflow>
+
+<Constraints>
+**Hard Blocks**:
+- [ ] Do not auto-escalate or switch modes; run `@Hack` as selected.
+</Constraints>