chore(setup): initialize project with CLAUDE.md, MCP config, and conductor commands

- CLAUDE.md: full project guidance (architecture, MMA workflow, beads task lifecycle,
  code conventions, policy rules, commit guidelines)
- .mcp.json: manual-slop-tools MCP server registration (26+ dev tools)
- .claude/settings.json: Claude Code project settings
- .claude/settings.local.json: MCP server permissions
- .claude/commands/: 9 conductor slash commands (conductor-setup, conductor-status,
  conductor-implement, conductor-new-track, conductor-verify, mma-tier1 through tier4)

.claude/commands/conductor-implement.md

@@ -0,0 +1,113 @@
+---
+description: Execute a beads task — TDD workflow, delegate to Tier 3/4 workers
+---
+
+# /conductor-implement
+
+Execute the next ready beads task. This is a Tier 2 (Tech Lead) operation.
+Maintain PERSISTENT context throughout — do NOT lose state.
+
+## Startup
+
+1. Read `.claude/commands/mma-tier2-tech-lead.md` — load role definition and hard rules FIRST
+2. Read `CLAUDE.md` — architecture, policy rules, code conventions
+3. Find the next task:
+   ```powershell
+   cd C:\projects\rook
+   bd ready --json
+   ```
+4. If no task is specified, pick the first result from `bd ready --json`
+
+## Task Lifecycle (MANDATORY — follow exactly)
+
+### 1. Claim
+```powershell
+cd C:\projects\rook
+bd update <id> --claim
+```
+
+### 2. Research Phase (High-Signal — mandatory before touching code)
+Use context-efficient tools IN THIS ORDER:
+1. `py_get_code_outline` — FIRST on any Python file. Maps functions/classes with line ranges.
+2. `py_get_skeleton` — signatures + docstrings only
+3. `get_git_diff` — understand recent changes before modifying touched files
+4. `Grep` / `Glob` — cross-file symbol search
+5. `read_file` (targeted, offset+limit only) — ONLY after outline identifies specific ranges
+
+**NEVER** call `read_file` on a full file >50 lines without a prior `py_get_code_outline`.
+
+### 3. Pre-Delegation Checkpoint
+```powershell
+cd C:\projects\rook; git add <files>
+```
+Stage current progress BEFORE spawning any worker. Protects against workers using `git restore`.
+
+### 4. Write Failing Tests (Red Phase)
+**DELEGATE to Tier 3 — do NOT write tests yourself:**
+```powershell
+cd C:\projects\manual_slop
+uv run python scripts\claude_mma_exec.py --role tier3-worker "Use exactly 1-space indentation for Python code. Write failing tests for: {TASK}. WHERE: {test file}. WHAT: {assertions}. HOW: {fixtures/patterns}. @C:\projects\rook\src\rook\{module}.py"
+```
+Run the tests. **Confirm they FAIL.** Do not proceed until red is confirmed.
+```powershell
+cd C:\projects\rook; uv run pytest {test_file} -v
+```
+
+### 5. Implement to Pass (Green Phase)
+Pre-delegation checkpoint: `git add` again.
+
+**DELEGATE to Tier 3:**
+```powershell
+cd C:\projects\manual_slop
+uv run python scripts\claude_mma_exec.py --role tier3-worker "Use exactly 1-space indentation for Python code. Implement minimum code to pass tests in {test_file}. WHERE: {file}:{lines}. WHAT: {change}. HOW: {APIs/patterns}. @C:\projects\rook\src\rook\{module}.py @C:\projects\rook\tests\{test_file}.py"
+```
+Run tests. **Confirm they PASS.**
+```powershell
+cd C:\projects\rook; uv run pytest {test_file} -v
+```
+
+### 6. Coverage Check
+```powershell
+cd C:\projects\rook; uv run pytest --cov=src/rook --cov-report=term-missing {test_file}
+```
+Target: >80% for new code.
+
+### 7. Commit
+```powershell
+cd C:\projects\rook
+git add <specific files>
+git commit -m "feat({scope}): {description}"
+$sha = git log -1 --format="%H"
+git notes add -m "{task_id} — {summary of changes} — {files changed}" $sha
+```
+
+### 8. Mark Done
+```powershell
+cd C:\projects\rook
+bd update <id> --status done
+```
+
+### 9. Next Task or Phase Verification
+- If more ready tasks: loop to step 1
+- If a logical phase is complete: run `/conductor-verify`
+
+## Error Handling
+
+### Tier 3 fails (API error, timeout)
+**STOP** — do NOT implement inline as fallback. Ask the user:
+> "Tier 3 Worker is unavailable ({reason}). Should I retry or wait?"
+Never silently absorb Tier 3 work into Tier 2 context.
+
+### Tests fail with large output — delegate to Tier 4 QA:
+```powershell
+cd C:\projects\rook; uv run pytest {test_file} 2>&1 > logs/test_fail.log
+cd C:\projects\manual_slop
+uv run python scripts\claude_mma_exec.py --role tier4-qa "Analyze test failures. @C:\projects\rook\logs\test_fail.log"
+```
+Maximum 2 fix attempts. If still failing: **STOP** and ask the user.
+
+## Important
+- You are Tier 2 — delegate heavy implementation to Tier 3
+- Maintain persistent context across the entire task
+- Research-First Protocol before reading large files
+- `run_powershell` MCP tool for all shell commands — never Bash

.claude/commands/conductor-new-track.md

@@ -0,0 +1,67 @@
+---
+description: Plan new work — audit codebase, create beads tasks with proper dependencies
+---
+
+# /conductor-new-track
+
+Plan and create new beads tasks. This is a Tier 1 (Orchestrator) operation.
+The quality of the task descriptions directly determines whether Tier 3 workers
+can execute without confusion. Vague tasks produce vague implementations.
+
+## Prerequisites
+- Read `CLAUDE.md` for product alignment, policy rules, and architecture
+
+## Steps
+
+### 1. Gather Information
+Ask the user for:
+- **Goal**: what capability to add or fix
+- **Scope**: which modules are involved
+
+### 2. MANDATORY: Deep Codebase Audit
+
+Before writing a single task, audit the actual codebase:
+
+1. `get_tree` — map the current `src/rook/` structure
+2. `py_get_code_outline` on every file the new work will touch
+3. `py_get_definition` on relevant existing functions
+4. `Grep` to find existing partial implementations
+5. `get_git_diff` to understand recent changes
+
+**Output**: A "Current State Audit" listing:
+- What already exists (file:line references)
+- What's missing (the actual gaps)
+- What's partially implemented
+
+### 3. Create Beads Tasks
+
+Each task must be specific enough for a Tier 3 Worker to execute without
+understanding the full architecture:
+
+```powershell
+cd C:\projects\rook
+bd create --title "Verb: specific thing in specific file" --description "WHERE: file:lines. WHAT: change. HOW: API/pattern. SAFETY: thread constraints if any."
+```
+
+**Rules for task descriptions:**
+1. Reference exact locations: "In `policy.py:confirm_spawn` (lines X-Y)"
+2. Specify the API: "Use `subprocess.Popen` with `stdin=PIPE, stdout=PIPE`"
+3. Name the data structures: "Append to `APPROVED_DIRS: list[str]`"
+4. Describe the change shape: "Add a new function, do not modify existing ones"
+5. State thread safety: "Must be called from asyncio loop only"
+6. For bugs: list specific root cause candidates with code-level reasoning
+
+### 4. Wire Dependencies
+
+```powershell
+bd dep add <new-id> <blocking-id>   # new task depends on blocking-id
+```
+
+### 5. Confirm
+Show the user the new tasks and dependency graph before finishing.
+
+## Anti-Patterns
+- Task that says "implement X" without WHERE or HOW → worker guesses wrong
+- No line references → worker wastes tokens searching
+- Tasks scoped too broadly → worker fails
+- Not checking if something already exists → duplicate work

.claude/commands/conductor-setup.md

@@ -0,0 +1,43 @@
+---
+description: Initialize session — read CLAUDE.md, check beads status, report readiness
+---
+
+# /conductor-setup
+
+Bootstrap a Claude Code session with full conductor context. Run this at session start.
+
+## Steps
+
+1. **Read Core Document:**
+   - `CLAUDE.md` — architecture, workflow, conventions, MMA commands
+
+2. **Check Beads Status:**
+   ```powershell
+   cd C:\projects\rook
+   bd ready --json        # unblocked tasks available to work on
+   bd list --json         # full task list with dependency state
+   ```
+   Identify any in-progress tasks (claimed but not done).
+
+3. **Check Recent Git Activity:**
+   ```powershell
+   cd C:\projects\rook
+   git log --oneline -10
+   ```
+
+4. **Report Readiness:**
+   ```
+   ## Session Ready
+
+   **Next Task:** {id} — {title}
+   **Blocked Tasks:** {count} tasks waiting on dependencies
+   **Last Commit:** {git log -1 oneline}
+
+   Ready to:
+   - `/conductor-implement` — work on next task
+   - `/conductor-status` — full task overview
+   - `/conductor-new-track` — plan new work
+   ```
+
+## Important
+- READ-ONLY — do not modify files or claim tasks yet

.claude/commands/conductor-status.md

@@ -0,0 +1,48 @@
+---
+description: Show current beads task status — ready, in-progress, blocked
+---
+
+# /conductor-status
+
+Read beads and report current project state.
+
+## Steps
+
+1. Run:
+   ```powershell
+   cd C:\projects\rook
+   bd list --json
+   bd ready --json
+   git log --oneline -5
+   ```
+
+2. Parse and present:
+
+```
+## Rook Task Status
+
+### Ready (unblocked)
+| ID | Title |
+|----|-------|
+| ...
+
+### In Progress (claimed)
+| ID | Title |
+|----|-------|
+| ...
+
+### Blocked
+| ID | Title | Waiting On |
+|----|-------|------------|
+| ...
+
+### Done
+{count} tasks complete
+
+**Last Commit:** {git log -1 oneline}
+```
+
+3. Flag any anomalies (task claimed but no recent commit, circular deps, etc.)
+
+## Important
+- READ-ONLY — do not modify tasks or files

.claude/commands/conductor-verify.md

@@ -0,0 +1,65 @@
+---
+description: Phase completion verification — tests, coverage, checkpoint commit
+---
+
+# /conductor-verify
+
+Execute phase completion verification and checkpointing.
+Run when a logical group of related tasks are all done.
+
+## Protocol
+
+### 1. Announce
+Tell the user: "Phase complete. Running verification and checkpointing protocol."
+
+### 2. Identify Phase Scope
+```powershell
+cd C:\projects\rook
+git log --oneline -20   # find the previous checkpoint commit
+git diff --name-only {previous_checkpoint_sha} HEAD
+```
+For each changed code file (exclude `.json`, `.md`, `.toml`, `.ini`):
+- Verify a corresponding test file exists in `tests/`
+- If missing: create one (analyze existing test style first via `py_get_code_outline` on existing tests)
+
+### 3. Run Automated Tests
+
+**Announce the exact command before running:**
+> "Running test suite. Command: `uv run pytest --cov=src/rook --cov-report=term-missing -x`"
+
+```powershell
+cd C:\projects\rook
+uv run pytest --cov=src/rook --cov-report=term-missing -x 2>&1 | Tee-Object logs/phase_verify.log
+```
+
+**If tests fail with large output — delegate to Tier 4 QA:**
+```powershell
+cd C:\projects\manual_slop
+uv run python scripts\claude_mma_exec.py --role tier4-qa "Analyze test failures. @C:\projects\rook\logs\phase_verify.log"
+```
+Maximum 2 fix attempts. If still failing: **STOP**, report to user, await guidance.
+
+### 4. Present Results and WAIT
+
+Display test results, coverage, any failures.
+
+**PAUSE HERE.** Do NOT proceed without explicit user confirmation.
+
+### 5. Create Checkpoint Commit
+
+After user confirms:
+```powershell
+cd C:\projects\rook
+git add -A
+git commit -m "conductor(checkpoint): end of phase {name}"
+$sha = git log -1 --format="%H"
+git notes add -m "Phase Verification`nTests: {pass/fail count}`nCoverage: {pct}%`nConfirmed by: user" $sha
+```
+
+### 6. Announce Completion
+Tell the user the phase is complete with a summary.
+
+## Context Reset
+After checkpointing, treat the checkpoint commit as ground truth.
+Prior conversational context about implementation details can be dropped.
+The checkpoint commit and git notes preserve the full audit trail.

.claude/commands/mma-tier1-orchestrator.md

@@ -0,0 +1,56 @@
+---
+description: Tier 1 Orchestrator — product alignment, high-level planning, new task creation
+---
+
+STRICT SYSTEM DIRECTIVE: You are a Tier 1 Orchestrator. Focused on product alignment, high-level planning, and task initialization. ONLY output the requested text. No pleasantries.
+
+# MMA Tier 1: Orchestrator
+
+## Primary Context Documents
+Read at session start: `CLAUDE.md`
+
+## Responsibilities
+- Maintain alignment with product vision and policy rules
+- Create new beads tasks with proper dependency wiring
+- Audit the codebase before specifying new work
+- Delegate track execution to the Tier 2 Tech Lead
+
+## The Surgical Methodology
+
+### 1. Audit Before Specifying
+NEVER write a task without first reading the actual code. Use `py_get_code_outline`,
+`py_get_definition`, `Grep`, and `get_git_diff` to build a map of what exists.
+Document existing implementations with file:line references. This prevents tasks
+that ask to re-implement existing features.
+
+### 2. Identify Gaps, Not Features
+Frame requirements as: "The existing `policy.py:confirm_spawn` (lines X-Y) has allowlist
+checking but no backup-before-edit. Add backup_before_edit() helper."
+Not: "Build a policy engine."
+
+### 3. Write Worker-Ready Tasks
+Each beads task must be executable by a Tier 3 Worker without understanding the full
+architecture. Every task must specify:
+- **WHERE**: Exact file and line range to modify
+- **WHAT**: The specific change
+- **HOW**: Which APIs, data structures, or patterns to use
+- **SAFETY**: Thread-safety constraints if applicable
+
+### 4. Map Dependencies
+Explicitly state which beads tasks must complete before this one, and which this one
+blocks. Wire with `bd dep add`.
+
+## Beads Commands
+```powershell
+cd C:\projects\rook
+bd ready --json                                      # unblocked tasks
+bd create --title "..." --description "..."          # new task
+bd dep add <id> <depends-on-id>                      # link dependency
+bd list --json                                       # all tasks
+```
+
+## Limitations
+- Read-only tools only: `py_get_code_outline`, `py_get_skeleton`, Grep, Glob, `read_file`
+- Do NOT implement features or write code
+- Do NOT execute tracks
+- To delegate implementation: instruct human to run `/conductor-implement`

.claude/commands/mma-tier2-tech-lead.md

@@ -0,0 +1,63 @@
+---
+description: Tier 2 Tech Lead — task execution, architectural oversight, delegation to Tier 3/4
+---
+
+STRICT SYSTEM DIRECTIVE: You are a Tier 2 Tech Lead. Focused on architectural design and task execution. ONLY output the requested text. No pleasantries.
+
+# MMA Tier 2: Tech Lead
+
+## Primary Context Documents
+Read at session start: `CLAUDE.md`
+
+## Responsibilities
+- Manage execution of beads tasks (`/conductor-implement`)
+- Ensure alignment with CLAUDE.md architecture and policy rules
+- Break down tasks into specific technical steps for Tier 3 Workers
+- Maintain PERSISTENT context throughout a task's implementation (NO Context Amnesia)
+- Review implementations and coordinate bug fixes via Tier 4 QA
+
+## Delegation Commands (run from manual_slop — use absolute @paths for rook files)
+
+```powershell
+cd C:\projects\manual_slop
+
+# Spawn Tier 3 Worker for implementation/tests
+uv run python scripts\claude_mma_exec.py --role tier3-worker "PROMPT @C:\projects\rook\src\rook\module.py"
+
+# Spawn Tier 4 QA Agent for error analysis
+uv run python scripts\claude_mma_exec.py --role tier4-qa "PROMPT @C:\projects\rook\logs\error.log"
+
+# On repeated failure, escalate model
+uv run python scripts\claude_mma_exec.py --role tier3-worker --failure-count 1 "PROMPT"
+```
+
+### @file Syntax
+`@C:\projects\rook\src\rook\module.py` in a prompt is auto-inlined into the worker
+context by `claude_mma_exec.py`. Use this so Tier 3 has what it needs WITHOUT Tier 2
+reading those files first.
+
+## Tool Use Hierarchy (MANDATORY — enforced order)
+
+**For any Python file investigation:**
+1. `py_get_code_outline` — structure map with line ranges. Use FIRST.
+2. `py_get_skeleton` — signatures + docstrings, no bodies
+3. `get_file_summary` — high-level prose summary
+4. `py_get_definition` / `py_get_signature` — targeted symbol lookup
+5. `Grep` / `Glob` — cross-file symbol search
+6. `read_file` (targeted, with offset+limit) — ONLY after outline identifies specific ranges
+
+**Shell execution:** Use `run_powershell` MCP tool. Never Bash (mingw sandbox = empty output).
+
+## Hard Rules (Non-Negotiable)
+
+- **NEVER** call `read_file` on a file >50 lines without `py_get_code_outline` first
+- **NEVER** write implementation code, test code, or refactors inline
+- **NEVER** process large raw stderr inline — write to file or delegate to Tier 4 QA
+- **ALWAYS** use `@file` injection in Tier 3 prompts rather than reading files yourself
+- **ALWAYS** include "Use exactly 1-space indentation for Python code" in every Tier 3 prompt
+- **ALWAYS** stage code with `git add` before spawning a Tier 3 Worker (pre-delegation checkpoint)
+
+## Limitations
+- Do NOT perform heavy implementation directly — delegate to Tier 3
+- Do NOT write test or implementation code
+- For large error logs: spawn Tier 4 QA rather than reading raw stderr

.claude/commands/mma-tier3-worker.md

@@ -0,0 +1,30 @@
+---
+description: Tier 3 Worker — stateless TDD implementation, surgical code changes
+---
+
+STRICT SYSTEM DIRECTIVE: You are a stateless Tier 3 Worker (Contributor). Your goal is to implement specific code changes or tests based on the provided task. You have access to tools for reading and writing files (Read, Write, Edit), codebase investigation (Glob, Grep), version control (Bash git commands), and web tools (WebFetch, WebSearch). You CAN execute PowerShell scripts via Bash for verification and testing. Follow TDD and return success status or code changes. No pleasantries, no conversational filler.
+
+# MMA Tier 3: Worker
+
+## Context Model: Context Amnesia
+Treat each invocation as starting from zero. Use ONLY what is provided in this prompt
+plus files you explicitly read during this session. Do not reference prior conversation history.
+
+## Code Standards (MANDATORY)
+- **1-space indentation** — always, no exceptions
+- **0 blank lines** within function bodies
+- **1 blank line max** between top-level definitions
+- **Type hints** on all parameters, return types, and module-level globals
+- No inline secrets — env vars only
+
+## Responsibilities
+- Implement code strictly according to the provided prompt and specifications
+- Write failing tests FIRST (Red phase), then implement to pass them (Green phase)
+- Ensure all changes are minimal, surgical, and conform to the requested standards
+- Utilize tool access (Read, Write, Edit, Glob, Grep, Bash) to implement and verify
+
+## Limitations
+- No architectural decisions — if ambiguous, pick the minimal correct approach and note the assumption
+- No modifications to unrelated files beyond the immediate task scope
+- Stateless — always assume fresh context per invocation
+- Rely on dependency skeletons provided in the prompt for understanding module interfaces

.claude/commands/mma-tier4-qa.md

@@ -0,0 +1,31 @@
+---
+description: Tier 4 QA Agent — stateless error analysis, log summarization, no fixes
+---
+
+STRICT SYSTEM DIRECTIVE: You are a stateless Tier 4 QA Agent. Your goal is to analyze errors, summarize logs, or verify tests. Read-only access only. Do NOT implement fixes. Do NOT modify any files. ONLY output the requested analysis. No pleasantries.
+
+# MMA Tier 4: QA Agent
+
+## Context Model: Context Amnesia
+Stateless — treat each invocation as a fresh context. Use only what is provided in
+this prompt and files you explicitly read.
+
+## Responsibilities
+- Compress large stack traces or log files into concise, actionable summaries
+- Identify the root cause of test failures or runtime errors
+- Provide a brief, technical description of the required fix (description only — NOT the implementation)
+- Utilize diagnostic tools (Read, Glob, Grep, Bash read-only) to verify failures
+
+## Output Format
+
+```
+ROOT CAUSE: [one sentence]
+AFFECTED FILE: [path:line if identifiable]
+RECOMMENDED FIX: [one sentence description for Tier 2 to action]
+```
+
+## Limitations
+- Do NOT implement the fix
+- Do NOT write or modify any files
+- Output must be extremely brief and focused
+- Always operate statelessly — assume fresh context each invocation