Migrate bitlesson and config infrastructure to staging branch

Cherry-pick bitlesson workflow, config-loader, model-router, and
config-driven defaults from feat/rlcr-loop-improvements (e3af54c)
onto origin/dev (1267861) via staging worktree.

29 files: 10 A-class (whole-file bitlesson), 7 B-class (config infra),
2 D-class (new test files), 10 C-class (mixed hunks extracted).
Excludes non-bitlesson/config changes (codex-worker, continue-rlcr-loop,
ask-codex routing, gen-plan template, etc.).

All 8 test suites pass (88 tests, 0 failures).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: zenus

.gitignore

@@ -1,8 +1,14 @@
 # Scratchpad
 temp
 
-# Humanize state directories (used by start-rlcr-loop)
-.humanize*
+# Local Claude client settings
+/.claude/settings.json
+
+# Humanize state directories (runtime-generated, project-local)
+.humanize/
+
+# Project-level bitlesson knowledge base (runtime-generated, project-local)
+/bitlesson.md
 
 # Python cache
 __pycache__/

agents/bitlesson-selector.md

@@ -0,0 +1,41 @@
+---
+name: bitlesson-selector
+description: Selects required BitLesson entries for a specific sub-task. Use before execution for every task or sub-task.
+model: haiku
+tools: Read, Grep
+---
+
+# BitLesson Selector
+
+You select which lessons from `bitlesson.md` must be applied for a given sub-task.
+
+## Input
+
+You will receive:
+- Current sub-task description
+- Related file paths
+- The project `bitlesson.md` content
+
+## Cross-Agent Review Context
+
+- This agent markdown serves as the prompt specification for BitLesson selection.
+- Runtime execution happens via `scripts/bitlesson-select.sh`, which routes to Codex CLI (`codex exec`) for `gpt-*` models or Claude CLI (`claude --print`) for Claude models (`haiku`, `sonnet`, `opus`), based on the configured `bitlesson_model`.
+- Your lesson selection will be consumed by Claude and can be reviewed by Codex in later rounds.
+- Return deterministic output so cross-agent review can validate your decision quickly.
+
+## Decision Rules
+
+1. Match only lessons that are directly relevant to the sub-task scope and failure mode.
+2. Prefer precision over recall: do not include weakly related lessons.
+3. If nothing is relevant, return `NONE`.
+
+## Output Format (Stable)
+
+Return exactly:
+
+```text
+LESSON_IDS: <comma-separated lesson IDs or NONE>
+RATIONALE: <one concise sentence>
+```
+
+No extra sections.

commands/start-rlcr-loop.md

@@ -68,8 +68,8 @@ If the pre-check passed (or was skipped), execute the setup script to initialize
 This command starts an iterative development loop where:
 
 1. You execute the implementation plan with task-tag routing
-   - `coding` tasks: Claude executes directly
-   - `analyze` tasks: execute via `/humanize:ask-codex`
+   - `coding` tasks: execute via the configured coding worker (see `coding_worker_model` config key)
+   - `analyze` tasks: execute via the configured analyzing worker (see `analyzing_worker_model` config key)
 2. Write a summary of your work to the specified summary file
 3. When you try to exit, Codex reviews your summary
 4. If Codex finds issues, you receive feedback and continue
@@ -89,7 +89,7 @@ This loop uses a **Goal Tracker** to prevent goal drift across iterations:
 ### Key Features
 1. **Acceptance Criteria**: Each task maps to a specific AC - nothing can be "forgotten"
 2. **Task Tag Routing**: Every task should carry `coding` or `analyze` tag from plan generation
-   - `coding -> Claude`, `analyze -> Codex`
+   - `coding -> worker`, `analyze -> analyzer`
 3. **Plan Evolution Log**: If you discover the plan needs changes, document the change with justification
 4. **Explicit Deferrals**: Deferred tasks require strong justification and impact analysis
 5. **Full Alignment Checks**: At configurable intervals (default every 5 rounds: rounds 4, 9, 14, etc.), Codex conducts a comprehensive goal alignment audit. Use `--full-review-round N` to customize (min: 2)
@@ -106,6 +106,21 @@ This loop uses a **Goal Tracker** to prevent goal drift across iterations:
 3. **Be thorough**: Include details about what was implemented, files changed, and tests added
 4. **No cheating**: Do not try to exit the loop by editing state files or running cancel commands
 5. **Trust the process**: Codex's feedback helps improve the implementation
+6. **Delegated agent context is mandatory**: Every delegated agent call must explicitly mention the worker/reviewer relationship and that review is **independent** (cross-vendor style), even if all models are OpenAI today.
+
+## BitLesson Workflow (Project Level)
+
+Each project must maintain its own `.humanize/bitlesson.md` file.
+If missing, `start-rlcr-loop` initializes it automatically with a strict template.
+
+Per round requirements:
+1. Read `.humanize/bitlesson.md` before execution
+2. Run `bitlesson-selector` for each task/sub-task
+3. Apply selected lesson IDs (or `NONE`) during implementation
+4. Include `## BitLesson Delta` in the round summary with `Action: none|add|update`
+
+If a problem is solved only after multiple rounds, add or update a precise lesson entry in `.humanize/bitlesson.md` (specific problem + specific solution).
+By default, empty `.humanize/bitlesson.md` does not block `Action: none`; use `--require-bitlesson-entry-for-none` to enforce strict blocking.
 
 ## Stopping the Loop
 
@@ -117,7 +132,7 @@ This loop uses a **Goal Tracker** to prevent goal drift across iterations:
 
 The RLCR loop has two phases within the active loop:
 
-1. **Implementation Phase**: Work by task tags (`coding -> Claude`, `analyze -> /humanize:ask-codex`), then Codex reviews your summary
+1. **Implementation Phase**: Work by task tags (`coding -> configured coding worker via coding_worker_model`, `analyze -> configured analyzing worker via analyzing_worker_model`), then Codex reviews your summary
 2. **Review Phase**: After COMPLETE, `codex review` checks code quality with `[P0-9]` severity markers
 
 The `--base-branch` option specifies the base branch for code review comparison. If not provided, it auto-detects from: remote default > local main > local master.

config/default_config.json

@@ -0,0 +1,17 @@
+{
+  "coding_worker_model": "gpt-5.3-codex",
+  "coding_worker_effort": "xhigh",
+  "analyzing_worker_model": "gpt-5.2",
+  "analyzing_worker_effort": "xhigh",
+  "task_reviewer_model": "gpt-5.2",
+  "task_reviewer_effort": "xhigh",
+  "loop_reviewer_model": "gpt-5.2",
+  "loop_reviewer_effort": "high",
+  "bitlesson_model": "haiku",
+  "agent_teams": false,
+  "chinese_plan": false,
+  "gen_plan_mode": "discussion",
+  "coding_worker": "Codex worker (via configured coding_worker_model)",
+  "analyzing_worker": "Codex (via configured analyzing_worker_model)",
+  "reviewer": "Codex reviewer (via configured task_reviewer_model)"
+}

hooks/lib/loop-common.sh

@@ -38,13 +38,19 @@ readonly FIELD_FULL_REVIEW_ROUND="full_review_round"
 readonly FIELD_ASK_CODEX_QUESTION="ask_codex_question"
 readonly FIELD_SESSION_ID="session_id"
 readonly FIELD_AGENT_TEAMS="agent_teams"
+readonly FIELD_DELEGATION_ENFORCEMENT="delegation_enforcement"
+readonly FIELD_LOOP_REVIEWER_EFFORT="loop_reviewer_effort"
 
-# Default Codex configuration (single source of truth - all scripts reference this)
+# Default Codex configuration (from merged config during library setup).
 # Both use :- so scripts can override before sourcing (e.g. PR loop sets different model/effort).
-#
-# Default model for Codex operations (same model for both plugin and skill mode)
-DEFAULT_CODEX_MODEL="${DEFAULT_CODEX_MODEL:-gpt-5.4}"
-DEFAULT_CODEX_EFFORT="${DEFAULT_CODEX_EFFORT:-high}"
+DEFAULT_CODEX_MODEL="${DEFAULT_CODEX_MODEL:-}"
+DEFAULT_CODEX_EFFORT="${DEFAULT_CODEX_EFFORT:-}"
+DEFAULT_LOOP_REVIEWER_MODEL="${DEFAULT_LOOP_REVIEWER_MODEL:-}"
+DEFAULT_LOOP_REVIEWER_EFFORT="${DEFAULT_LOOP_REVIEWER_EFFORT:-}"
+
+# Default worker configuration (used by /humanize:codex-worker).
+DEFAULT_CODEX_WORKER_MODEL="${DEFAULT_CODEX_WORKER_MODEL:-}"
+DEFAULT_CODEX_WORKER_EFFORT="${DEFAULT_CODEX_WORKER_EFFORT:-}"
 
 # Codex review markers
 readonly MARKER_COMPLETE="COMPLETE"
@@ -157,6 +163,48 @@ is_deeply_nested() {
 
 # Source template loader
 LOOP_COMMON_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+LOOP_COMMON_PLUGIN_ROOT="$(cd "$LOOP_COMMON_DIR/../.." && pwd)"
+export PLUGIN_ROOT="${PLUGIN_ROOT:-$LOOP_COMMON_PLUGIN_ROOT}"
+
+_lc_errexit=false; [[ -o errexit ]] && _lc_errexit=true
+_lc_nounset=false; [[ -o nounset ]] && _lc_nounset=true
+_lc_pipefail=false; [[ -o pipefail ]] && _lc_pipefail=true
+source "$LOOP_COMMON_PLUGIN_ROOT/scripts/lib/config-loader.sh"
+$_lc_errexit && set -e || set +e
+$_lc_nounset && set -u || set +u
+$_lc_pipefail && set -o pipefail || set +o pipefail
+unset _lc_errexit _lc_nounset _lc_pipefail
+
+_LOOP_COMMON_PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+# Config loading is best-effort: callers like setup-rlcr-loop.sh have their own
+# authoritative dependency checks (jq, codex) that produce clear error messages.
+# Suppress stderr to avoid noisy intermediate errors (e.g., "jq: command not found")
+# before the caller's check runs, and use || true so a config-load failure does not
+# abort sourcing before those checks are reached.
+_LOOP_COMMON_CONFIG="$(load_merged_config "$LOOP_COMMON_PLUGIN_ROOT" "$_LOOP_COMMON_PROJECT_ROOT" 2>/dev/null)" || true
+
+_cfg_analyzing_model="$(get_config_value "$_LOOP_COMMON_CONFIG" analyzing_worker_model 2>/dev/null || jq -r '.analyzing_worker_model // empty' "$LOOP_COMMON_PLUGIN_ROOT/config/default_config.json" 2>/dev/null || true)"
+_cfg_analyzing_effort="$(get_config_value "$_LOOP_COMMON_CONFIG" analyzing_worker_effort 2>/dev/null || jq -r '.analyzing_worker_effort // empty' "$LOOP_COMMON_PLUGIN_ROOT/config/default_config.json" 2>/dev/null || true)"
+_cfg_coding_model="$(get_config_value "$_LOOP_COMMON_CONFIG" coding_worker_model 2>/dev/null || jq -r '.coding_worker_model // empty' "$LOOP_COMMON_PLUGIN_ROOT/config/default_config.json" 2>/dev/null || true)"
+_cfg_coding_effort="$(get_config_value "$_LOOP_COMMON_CONFIG" coding_worker_effort 2>/dev/null || jq -r '.coding_worker_effort // empty' "$LOOP_COMMON_PLUGIN_ROOT/config/default_config.json" 2>/dev/null || true)"
+_cfg_reviewer_model="$(get_config_value "$_LOOP_COMMON_CONFIG" loop_reviewer_model 2>/dev/null || jq -r '.loop_reviewer_model // empty' "$LOOP_COMMON_PLUGIN_ROOT/config/default_config.json" 2>/dev/null || true)"
+_cfg_reviewer_effort="$(get_config_value "$_LOOP_COMMON_CONFIG" loop_reviewer_effort 2>/dev/null || jq -r '.loop_reviewer_effort // empty' "$LOOP_COMMON_PLUGIN_ROOT/config/default_config.json" 2>/dev/null || true)"
+
+# Default analyzer configuration (used by codex analyzing/review worker flows).
+# Hard fallbacks guard against jq being absent or config loading failing entirely;
+# the literals here must match the values in config/default_config.json.
+DEFAULT_CODEX_MODEL="${DEFAULT_CODEX_MODEL:-${_cfg_analyzing_model:-gpt-5.2}}"
+DEFAULT_CODEX_EFFORT="${DEFAULT_CODEX_EFFORT:-${_cfg_analyzing_effort:-xhigh}}"
+
+# Default worker configuration (used by /humanize:codex-worker).
+DEFAULT_CODEX_WORKER_MODEL="${DEFAULT_CODEX_WORKER_MODEL:-${_cfg_coding_model:-gpt-5.3-codex}}"
+DEFAULT_CODEX_WORKER_EFFORT="${DEFAULT_CODEX_WORKER_EFFORT:-${_cfg_coding_effort:-xhigh}}"
+DEFAULT_LOOP_REVIEWER_MODEL="${DEFAULT_LOOP_REVIEWER_MODEL:-${_cfg_reviewer_model:-gpt-5.2}}"
+DEFAULT_LOOP_REVIEWER_EFFORT="${DEFAULT_LOOP_REVIEWER_EFFORT:-${_cfg_reviewer_effort:-high}}"
+
+unset _cfg_analyzing_model _cfg_analyzing_effort _cfg_coding_model _cfg_coding_effort _cfg_reviewer_model _cfg_reviewer_effort
+unset _LOOP_COMMON_PROJECT_ROOT _LOOP_COMMON_CONFIG
+
 source "$LOOP_COMMON_DIR/template-loader.sh"
 
 # Initialize template directory (can be overridden by sourcing script)
@@ -330,6 +378,8 @@ _parse_state_fields() {
     STATE_ASK_CODEX_QUESTION=$(echo "$STATE_FRONTMATTER" | grep "^${FIELD_ASK_CODEX_QUESTION}:" | sed "s/${FIELD_ASK_CODEX_QUESTION}: *//" | tr -d ' ' || true)
     STATE_SESSION_ID=$(echo "$STATE_FRONTMATTER" | grep "^${FIELD_SESSION_ID}:" | sed "s/${FIELD_SESSION_ID}: *//" || true)
     STATE_AGENT_TEAMS=$(echo "$STATE_FRONTMATTER" | grep "^${FIELD_AGENT_TEAMS}:" | sed "s/${FIELD_AGENT_TEAMS}: *//" | tr -d ' ' || true)
+    STATE_DELEGATION_ENFORCEMENT=$(echo "$STATE_FRONTMATTER" | grep "^${FIELD_DELEGATION_ENFORCEMENT}:" | sed "s/${FIELD_DELEGATION_ENFORCEMENT}: *//" | tr -d ' ' || true)
+    STATE_LOOP_REVIEWER_EFFORT=$(echo "$STATE_FRONTMATTER" | grep "^${FIELD_LOOP_REVIEWER_EFFORT}:" | sed "s/${FIELD_LOOP_REVIEWER_EFFORT}: *//" | tr -d ' ' || true)
 }
 
 # Parse state file frontmatter and set variables (tolerant mode with defaults)
@@ -349,6 +399,8 @@ _parse_state_fields() {
 #   STATE_REVIEW_STARTED - "true" or "false"
 #   STATE_FULL_REVIEW_ROUND - interval for Full Alignment Check (default: 5)
 #   STATE_ASK_CODEX_QUESTION - "true" or "false" (v1.6.5+)
+#   STATE_AGENT_TEAMS - "true" or "false"
+#   STATE_DELEGATION_ENFORCEMENT - "warn" or "strict"
 # Returns: 0 on success, 1 if file not found
 # Note: For strict validation, use parse_state_file_strict() instead
 parse_state_file() {
@@ -371,6 +423,7 @@ parse_state_file() {
     STATE_FULL_REVIEW_ROUND="${STATE_FULL_REVIEW_ROUND:-5}"
     STATE_ASK_CODEX_QUESTION="${STATE_ASK_CODEX_QUESTION:-true}"
     STATE_AGENT_TEAMS="${STATE_AGENT_TEAMS:-false}"
+    STATE_DELEGATION_ENFORCEMENT="${STATE_DELEGATION_ENFORCEMENT:-warn}"
     # STATE_REVIEW_STARTED left as-is (empty if missing, to allow schema validation)
 
     return 0
@@ -446,6 +499,7 @@ parse_state_file_strict() {
     STATE_FULL_REVIEW_ROUND="${STATE_FULL_REVIEW_ROUND:-5}"
     STATE_ASK_CODEX_QUESTION="${STATE_ASK_CODEX_QUESTION:-true}"
     STATE_AGENT_TEAMS="${STATE_AGENT_TEAMS:-false}"
+    STATE_DELEGATION_ENFORCEMENT="${STATE_DELEGATION_ENFORCEMENT:-warn}"
 
     return 0
 }