monomind 1.19.0 → 2.0.1

package/.claude/skills/mastermind-skills/bootstrap.md

@@ -1,190 +0,0 @@
----
-name: mastermind-bootstrap
-description: Mastermind bootstrap — one-time org initialization that primes the CEO/boss agent with org context, goal hierarchy, and a signed invite token. Run after createorg before first runorg.
-type: domain-skill
-default_mode: confirm
----
-
-# Mastermind Bootstrap
-
-This skill is invoked by `mastermind:bootstrap` or directly via `/mastermind:bootstrap`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `org_name`: org to bootstrap (required)
-- `action`: init | token | status | reset
-- `boss_role_id`: role ID of the CEO/boss agent (default: auto-detect by `reports_to: null`)
-- `caller`: command | master
-
----
-
-## Step 0 — Brain Load (standalone only)
-
-If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
-
----
-
-## Step 1 — Resolve Org
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found. Run /mastermind:createorg first."; exit 1; }
-
-bootstrapFile=".monomind/orgs/${org_name}-bootstrap.json"
-```
-
----
-
-## Step 2 — Execute Action
-
-### status (check bootstrap state)
-
-```bash
-if [ -f "$bootstrapFile" ]; then
-  echo "BOOTSTRAP STATUS — ${org_name}"
-  echo "──────────────────────────────────"
-  jq -r '
-    "  State:       \(.state // "unknown")",
-    "  Boss Role:   \(.boss_role_id // "-")",
-    "  Bootstrapped:\(.bootstrapped_at // "never")",
-    "  Token:       \(if .invite_token then (.invite_token | .[0:8]) + "..." else "none" end)",
-    "  Token used:  \(.token_used // false)"
-  ' "$bootstrapFile"
-else
-  echo "Not bootstrapped. Run /mastermind:bootstrap --org ${org_name} --action init"
-fi
-```
-
-### token (generate a fresh invite token)
-
-Generate a signed one-time token the boss agent uses to authenticate its first session:
-
-```bash
-token=$(openssl rand -hex 24 2>/dev/null || python3 -c "import secrets; print(secrets.token_hex(24))")
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-echo "INVITE TOKEN — ${org_name}"
-echo "──────────────────────────────────"
-echo "  Token: $token"
-echo "  Valid until first use."
-echo ""
-
-# Store token in bootstrap file
-[ ! -f "$bootstrapFile" ] && echo '{}' > "$bootstrapFile"
-tmp="${bootstrapFile}.tmp"
-jq --arg token "$token" --arg ts "$ts" \
-  '.invite_token = $token | .token_generated_at = $ts | .token_used = false' \
-  "$bootstrapFile" > "$tmp" && mv "$tmp" "$bootstrapFile"
-echo "Token stored. Include in boss agent prompt as: INVITE_TOKEN=${token}"
-```
-
-### init (full bootstrap)
-
-Initialize org bootstrap: detect boss, generate token, write primer context:
-
-```bash
-# Auto-detect boss (role with no reports_to or reports_to: null)
-if [ -z "$boss_role_id" ]; then
-  boss_role_id=$(jq -r '(.roles // [])[] | select(.reports_to == null or .reports_to == "") | .id' "$orgFile" | head -1)
-fi
-[ -z "$boss_role_id" ] && { echo "ERROR: Could not detect boss role. Pass --boss-role-id <id>."; exit 1; }
-
-bossConfig=$(jq --arg id "$boss_role_id" '(.roles // [])[] | select(.id == $id)' "$orgFile")
-bossTitle=$(echo "$bossConfig" | jq -r '.title // "CEO"')
-orgGoal=$(jq -r '.goal // "No goal set"' "$orgFile")
-orgTopology=$(jq -r '.topology // "hierarchical"' "$orgFile")
-roleCount=$(jq '.roles | length' "$orgFile")
-governance=$(jq -r '.governance.policy // "auto"' "$orgFile")
-
-# Generate invite token
-token=$(openssl rand -hex 24 2>/dev/null || python3 -c "import secrets; print(secrets.token_hex(24))")
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-# Write bootstrap record
-cat > "$bootstrapFile" <<EOF
-{
-  "org": "${org_name}",
-  "state": "initialized",
-  "boss_role_id": "${boss_role_id}",
-  "boss_title": "${bossTitle}",
-  "org_goal": "${orgGoal}",
-  "topology": "${orgTopology}",
-  "role_count": ${roleCount},
-  "governance": "${governance}",
-  "invite_token": "${token}",
-  "token_used": false,
-  "token_generated_at": "${ts}",
-  "bootstrapped_at": "${ts}"
-}
-EOF
-
-echo "BOOTSTRAP COMPLETE — ${org_name}"
-echo "──────────────────────────────────────────"
-echo "  Boss:       ${bossTitle} (${boss_role_id})"
-echo "  Goal:       ${orgGoal}"
-echo "  Topology:   ${orgTopology}"
-echo "  Agents:     ${roleCount}"
-echo "  Governance: ${governance}"
-echo "  Token:      ${token}"
-echo ""
-echo "CEO PRIMER (include in boss agent prompt):"
-echo "──────────────────────────────────────────"
-cat <<PRIMER
-ORG: ${org_name}
-ROLE: ${bossTitle}
-GOAL: ${orgGoal}
-GOVERNANCE: ${governance}
-INVITE_TOKEN: ${token}
-
-You are the autonomous CEO of org '${org_name}'. Your mission: ${orgGoal}.
-You lead ${roleCount} agents in a ${orgTopology} topology.
-Governance mode: ${governance}. In 'board' or 'strict' mode, pause before high-risk actions and emit approval requests.
-Use your INVITE_TOKEN for your first heartbeat. Token is single-use.
-PRIMER
-```
-
-Emit `org:bootstrap:complete` event:
-
-```bash
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
-  -H "Content-Type: application/json" \
-  -d "$(jq -cn --arg org "$org_name" --arg boss "$boss_role_id" \
-    '{type:"org:bootstrap:complete",org:$org,boss:$boss,ts:(now*1000|floor)}')" || true
-```
-
-### reset
-
-Clear bootstrap state (next init will regenerate token):
-
-```bash
-if [ -f "$bootstrapFile" ]; then
-  rm "$bootstrapFile"
-  echo "Bootstrap state cleared for '${org_name}'. Run --action init to re-bootstrap."
-else
-  echo "No bootstrap file found for '${org_name}'."
-fi
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org: <org_name>
-boss_role_id: <boss_role_id>
-state: initialized | token | reset
-```
-
----
-
-## Step 4 — Brain Write (standalone only)
-
-If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind-skills/budgets.md

@@ -1,237 +0,0 @@
----
-name: mastermind-budgets
-description: Mastermind budgets — view, set, and track token/cost budgets for agents and the entire org. Shows current spend vs. limits, alerts on overages, and lets board members adjust per-agent or org-wide budgets. Reads from -budgets.json org state files.
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Budgets
-
-This skill is invoked by `mastermind:budgets` or directly via `/mastermind:budgets`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `org_name`: org to manage budgets for (required)
-- `action`: show | set | reset | alert
-- `agent_id`: scope to a specific agent (optional — omit for org-wide)
-- `limit_tokens`: token limit to set (for set)
-- `limit_usd`: USD cost limit to set (for set)
-- `caller`: command | master
-
----
-
-## Step 0 — Brain Load (standalone only)
-
-If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
-
----
-
-## Step 1 — Load Org and Budget File
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
-
-budgetsFile=".monomind/orgs/${org_name}-budgets.json"
-stateFile=".monomind/orgs/${org_name}-state.json"
-
-if [ ! -f "$budgetsFile" ]; then
-  echo '{"org_budget":{},"agent_budgets":{},"period":"monthly","currency":"USD"}' > "$budgetsFile"
-fi
-```
-
----
-
-## Step 2 — Execute Action
-
-### show (default)
-
-```bash
-echo "BUDGETS — $org_name"
-echo "════════════════════════════════════════════════════════"
-
-python3 - "$orgFile" "$budgetsFile" "$stateFile" "${agent_id:-}" <<'PYEOF'
-import json, sys, os
-
-orgData    = json.load(open(sys.argv[1]))
-budgetData = json.load(open(sys.argv[2]))
-statePath  = sys.argv[3]
-agentFilter= sys.argv[4]
-
-# Load heartbeat state for per-agent token usage
-agentTokens = {}
-if os.path.exists(statePath):
-    try:
-        state = json.load(open(statePath))
-        for r in state.get("roles", []):
-            rid = r.get("id","")
-            agentTokens[rid] = {
-                "tokensIn":  r.get("tokens_in", 0),
-                "tokensOut": r.get("tokens_out", 0),
-                "totalCostUsd": r.get("total_cost_usd", 0.0),
-            }
-    except: pass
-
-orgBudget   = budgetData.get("org_budget", {})
-agentBudgets= budgetData.get("agent_budgets", {})
-period      = budgetData.get("period", "monthly")
-
-print(f"  Period: {period}")
-print()
-
-# Org-wide budget
-orgLimitTokens = orgBudget.get("limit_tokens")
-orgLimitUsd    = orgBudget.get("limit_usd")
-orgSpentTokens = sum(v.get("tokensIn",0) + v.get("tokensOut",0) for v in agentTokens.values())
-orgSpentUsd    = sum(v.get("totalCostUsd",0) for v in agentTokens.values())
-
-print("ORG BUDGET")
-print("────────────────────────────────────────────────────────")
-print(f"  Tokens spent:  {orgSpentTokens:>12,}")
-if orgLimitTokens:
-    pct = orgSpentTokens / orgLimitTokens * 100
-    bar = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
-    print(f"  Token limit:   {orgLimitTokens:>12,}  [{bar}] {pct:.1f}%")
-print(f"  Cost (USD):    ${orgSpentUsd:>11.4f}")
-if orgLimitUsd:
-    pct = orgSpentUsd / orgLimitUsd * 100
-    bar = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
-    print(f"  Cost limit:    ${orgLimitUsd:>11.2f}    [{bar}] {pct:.1f}%")
-print()
-
-# Per-agent budgets
-roles = orgData.get("roles", [])
-if agentFilter:
-    roles = [r for r in roles if r.get("id") == agentFilter]
-
-print("AGENT BUDGETS")
-print("────────────────────────────────────────────────────────")
-print(f"  {'AGENT':<28} {'TOKENS IN':<12} {'TOKENS OUT':<12} {'COST USD':<12} {'LIMIT USD'}")
-print("  " + "─" * 82)
-
-for role in roles:
-    rid   = role.get("id","?")
-    title = role.get("title", rid)[:26]
-    tok   = agentTokens.get(rid, {})
-    tIn   = tok.get("tokensIn", 0)
-    tOut  = tok.get("tokensOut", 0)
-    cost  = tok.get("totalCostUsd", 0.0)
-    lim   = agentBudgets.get(rid, {}).get("limit_usd")
-    limStr= f"${lim:.2f}" if lim else "—"
-
-    overBudget = lim and cost > lim
-    flag = " ⚠ OVER" if overBudget else ""
-    print(f"  {title:<28} {tIn:<12,} {tOut:<12,} ${cost:<11.4f} {limStr}{flag}")
-
-if not roles:
-    print("  (no agents)")
-PYEOF
-
-echo ""
-echo "  Set limit: /mastermind:budgets --org $org_name --action set --agent-id <id> --limit-usd 5.00"
-echo "  Reset:     /mastermind:budgets --org $org_name --action reset"
-```
-
-### set
-
-```bash
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-python3 - "$budgetsFile" "${agent_id:-}" "${limit_tokens:-}" "${limit_usd:-}" "$ts" <<'PYEOF'
-import json, sys
-
-path, agentId, limitTok, limitUsd, ts = sys.argv[1:]
-
-data = json.load(open(path))
-
-if agentId:
-    entry = data.setdefault("agent_budgets", {}).setdefault(agentId, {})
-    if limitTok: entry["limit_tokens"] = int(limitTok)
-    if limitUsd:  entry["limit_usd"] = float(limitUsd)
-    entry["updatedAt"] = ts
-    print(f"  Budget set for agent '{agentId}':")
-    if limitTok: print(f"    Token limit: {int(limitTok):,}")
-    if limitUsd:  print(f"    USD limit:   ${float(limitUsd):.2f}")
-else:
-    org = data.setdefault("org_budget", {})
-    if limitTok: org["limit_tokens"] = int(limitTok)
-    if limitUsd:  org["limit_usd"] = float(limitUsd)
-    org["updatedAt"] = ts
-    print(f"  Org-wide budget updated:")
-    if limitTok: print(f"    Token limit: {int(limitTok):,}")
-    if limitUsd:  print(f"    USD limit:   ${float(limitUsd):.2f}")
-
-with open(path, "w") as f:
-    json.dump(data, f, indent=2)
-PYEOF
-```
-
-### reset
-
-```bash
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-echo '{"org_budget":{},"agent_budgets":{},"period":"monthly","currency":"USD","resetAt":"'"$ts"'"}' > "$budgetsFile"
-echo "  Budget counters reset for '$org_name'  ($ts)"
-echo "  Note: resets limit configs too. Re-run --action set to restore limits."
-```
-
-### alert
-
-Check for agents over their budget limits:
-
-```bash
-echo "BUDGET ALERTS — $org_name"
-echo "────────────────────────────────────────────────────────"
-
-python3 - "$orgFile" "$budgetsFile" "$stateFile" <<'PYEOF'
-import json, sys, os
-
-orgData    = json.load(open(sys.argv[1]))
-budgetData = json.load(open(sys.argv[2]))
-statePath  = sys.argv[3]
-
-agentTokens = {}
-if os.path.exists(statePath):
-    try:
-        state = json.load(open(statePath))
-        for r in state.get("roles", []):
-            rid = r.get("id","")
-            agentTokens[rid] = r.get("total_cost_usd", 0.0)
-    except: pass
-
-agentBudgets = budgetData.get("agent_budgets", {})
-alerts = []
-for rid, ab in agentBudgets.items():
-    lim = ab.get("limit_usd")
-    spent = agentTokens.get(rid, 0.0)
-    if lim and spent > lim:
-        alerts.append((rid, spent, lim))
-
-if not alerts:
-    print("  ✓ All agents within budget.")
-else:
-    print(f"  ⚠ {len(alerts)} agent(s) over budget:")
-    for rid, spent, lim in alerts:
-        print(f"    {rid}: spent ${spent:.4f} / limit ${lim:.2f}")
-PYEOF
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org_name: <org_name>
-```
-
----
-
-## Step 4 — Brain Write (standalone only)
-
-If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind-skills/build.md

@@ -1,170 +0,0 @@
----
-name: mastermind-build
-description: Mastermind build domain — development automation for features, bugs, refactors, and code review. Spawns a Development Manager agent who creates monotask tasks and coordinates specialized sub-agent swarms.
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Build Domain
-
-This skill is invoked by `mastermind:master` or directly via `/mastermind:build`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
-- `prompt`: the goal for this build run
-- `project_name`: monotask space name
-- `board_id`: monotask board ID (set by master, or created standalone)
-- `mode`: auto | confirm
-
----
-
-## Complexity Assessment
-
-Assess the prompt to determine execution mode:
-
-**Simple (direct skill execution):** Single task, single agent, one file:
-- "Fix the typo in /src/auth.ts line 42"
-- "Add a console.log to debug X"
-→ Use the Edit tool or Task with a single coder agent. Skip manager delegation.
-
-**Complex (spawn Development Manager agent):** Any of these:
-- 3+ files to create/modify
-- Requires frontend + backend + testing
-- New feature with architecture decisions
-- Performance optimization across modules
-- Security fix with audit trail needed
-→ Spawn Development Manager agent with full briefing.
-
----
-
-## Standalone Execution (when called without master)
-
-If this skill is invoked directly (not by master):
-
-1. Load brain context following _protocol.md Brain Load Procedure (namespace: `build`)
-2. Run intake from _intake.md if prompt is vague
-3. Follow _protocol.md Monotask Space+Board Setup Procedure:
-   ```bash
-   project_name="${project_name:-$(basename "$PWD")}"
-   space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
-   [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
-   [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
-   board_id=$(monotask board create "development" --json | jq -r '.id // empty')
-   [ -z "$board_id" ] && { echo "ERROR: Failed to create development board"; exit 1; }
-   monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
-   todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
-   doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
-   done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
-   ```
-4. Proceed with complexity assessment below
-5. At end: follow _protocol.md Brain Write Procedure (namespace: `build`)
-
----
-
-## Complex Execution — Development Manager Agent
-
-Spawn a Development Manager agent via Task tool:
-
-```javascript
-Task({
-  subagent_type: "coordinator",
-  description: `You are the Development Manager for project <project_name>.
-
-CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:build
-
-BRAIN CONTEXT:
-<brain_context>
-
-YOUR BOARD: <board_id>
-YOUR GOAL: <prompt>
-
-STEP 1 — PLAN
-Decompose the goal into discrete development tasks. For each task, identify:
-- Which files are affected
-- What type of work it is (backend, frontend, test, review)
-- Dependencies between tasks
-- Estimated complexity
-
-STEP 2 — CREATE TASKS
-For each task, create a monotask card on the project board. First look up column IDs and assign shell variables:
-```bash
-columns=$(monotask column list "$BOARD_ID" --json)
-COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
-COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
-```
-Then create the card:
-```bash
-result=$(monotask card create "$BOARD_ID" "$COL_TODO_ID" "<short summary of task goal, ≤80 chars>" --json)
-CARD_ID=$(echo "$result" | jq -r '.id // empty')
-monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific task goal]"
-monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Development Manager
-BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
-SCOPE: [exact file paths in scope]
-CONSTRAINTS: [must-not-break items, existing APIs to preserve]
-SUCCESS CRITERIA:
-- [ ] [checkable item]
-AGENT: [backend-dev | frontend-dev | tester | reviewer | sparc-coder]
-SWARM: hierarchical 4 raft
-DEPENDENCIES: [task IDs or \"none\"]
-OUTPUT FORMAT: unified output schema"
-```
-
-STEP 3 — EXECUTE
-Spawn one Task agent per task (all in parallel where dependencies allow):
-- Backend tasks: subagent_type "backend-dev"
-- Frontend tasks: subagent_type "frontend-dev"
-- Testing tasks: subagent_type "tester"
-- Code review: subagent_type "reviewer"
-- TDD/SPARC work: subagent_type "sparc-coder"
-
-Also run /mastermind:do --board <board_id> to track execution.
-
-STEP 4 — COLLECT AND RETURN
-Collect all agent output schemas. Return to caller:
-
-domain: build
-status: complete | partial | blocked
-artifacts:
-  - path: [each file created/modified]
-    type: code
-decisions:
-  - what: [architectural decisions made]
-    why: [reasoning]
-    confidence: [0.0-1.0]
-    outcome: shipped | pending
-lessons:
-  - what_worked: [what helped]
-  - what_didnt: [what didn't]
-next_actions:
-  - [suggested follow-ups like "run mastermind:review"]
-board_url: monotask://<project_name>/development
-run_id: <ISO8601-timestamp>`,
-  run_in_background: true
-})
-```
-
----
-
-## Simple Execution
-
-For simple tasks (single agent, single file):
-
-1. Spawn one Task agent with the task as a self-contained briefing
-2. Collect output
-3. Return unified output schema with `status: complete`
-
----
-
-## Domain Swarm Defaults
-
-| Task Type | Agent | Swarm |
-|---|---|---|
-| Feature development | coordinator | hierarchical 6 raft specialized |
-| Bug fix | coder + tester | hierarchical 4 raft specialized |
-| Refactor | coordinator | hierarchical 5 raft specialized |
-| Performance | perf-analyzer + coder | star 4 parallel |
-| Security fix | security-architect + auditor | hive-mind hierarchical-mesh byzantine 6 |
-| Code review | reviewer | mesh 4 gossip balanced |

package/.claude/skills/mastermind-skills/code-quality-reviewer-prompt.md

@@ -1,60 +0,0 @@
-# Code Quality Reviewer Prompt Template
-
-Use this template when dispatching a code quality reviewer subagent from `mastermind:taskdev`.
-
-**Purpose:** Verify implementation is well-built — clean, tested, maintainable.
-
-**Only dispatch AFTER spec compliance review passes (✅).** Never run this first.
-
-```
-Task tool (general-purpose):
-  description: "Code quality review for Task N: [task name]"
-  prompt: |
-    You are reviewing the code quality of a recently implemented task.
-
-    ## Task Summary
-
-    [From implementer's report — what was built]
-
-    ## Diff to Review
-
-    BASE_SHA: [commit before task]
-    HEAD_SHA: [current commit after task]
-
-    Review the changes introduced between these commits.
-
-    ## What to Check
-
-    **Code quality:**
-    - Is the code clean and maintainable?
-    - Are names clear and accurate (match what things do, not how they work)?
-    - Is there duplication that could be DRY'd up?
-    - Are there magic numbers or hardcoded strings that should be constants?
-
-    **File structure:**
-    - Does each file have one clear responsibility with a well-defined interface?
-    - Are units decomposed so they can be understood and tested independently?
-    - Is the implementation following the file structure from the plan?
-    - Did this task create new files that are already large, or significantly grow
-      existing files? (Focus on what this change contributed, not pre-existing sizes.)
-
-    **Tests:**
-    - Do tests actually verify behavior (not just mock behavior)?
-    - Is test coverage adequate for the functionality added?
-    - Are tests readable and well-named?
-
-    **YAGNI / over-engineering:**
-    - Was anything built that wasn't needed?
-    - Is any abstraction premature?
-
-    ## Report Format
-
-    Return:
-    - **Strengths:** What was done well
-    - **Issues (Critical):** Must fix before proceeding
-    - **Issues (Important):** Should fix — notable quality problems
-    - **Issues (Minor):** Nice to have — low priority
-    - **Assessment:** ✅ Approved | ❌ Needs fixes
-
-    If issues are found, the implementer will fix them and you will re-review.
-```