besimple-broccoli-blind

# Sketch -> Auto-select -> Plan -> Critique -> Implement -> Simplify -> Dedup -> Review (blind wrapper)

This is the automation-safe variant of `besimple-broccoli`.

- It uses the same planning + implementation flow.
- It automatically chooses **recommended** clarification options.
- It does **not** open PRs and does **not** post Linear comments.

## Preconditions

- Confirm repo: `git rev-parse --show-toplevel`
- Ensure CLIs: `codex`, `claude`
- Ensure git commits are possible (`user.name` / `user.email` configured)

## Required subskills

- `plan-sketch`
- `plan-write`
- `plan-critique-loop`
- `implement-from-plan`
- `claude-simplify-wrapper`
- `dedup`
- `code-review-loop`

## Workflow

0. **Prepare subagent logs and heartbeat**
   ```bash
   LOG_DIR="/tmp/codex-subagent-logs/$(basename "$PWD")"
   HEARTBEAT_SECONDS=60
   SUBAGENT_TIMEOUT_SECONDS=7200
   mkdir -p "${LOG_DIR}"
   SKETCH_LOG="${LOG_DIR}/plan-sketch.log"
   WRITE_LOG="${LOG_DIR}/plan-write.log"
   CRITIQUE_LOG="${LOG_DIR}/plan-critique.log"
   SIMPLIFY_LOG="${LOG_DIR}/simplify.log"
   DEDUP_LOG="${LOG_DIR}/dedup.log"
   REVIEW_LOG="${LOG_DIR}/code-review.log"
   : > "${SKETCH_LOG}"
   : > "${WRITE_LOG}"
   : > "${CRITIQUE_LOG}"
   : > "${SIMPLIFY_LOG}"
   : > "${DEDUP_LOG}"
   : > "${REVIEW_LOG}"
   ```

   Resolve installed skill directories (so the wrapper works from any repo):
   ```bash
   resolve_skill_dir() {
     local name="$1"
     local repo_root=""
     repo_root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"

     local candidates=(
       "$repo_root/.agents/skills/$name"
       "$repo_root/.claude/skills/$name"
       "$HOME/.agents/skills/$name"
       "$HOME/.codex/skills/$name"
       "$HOME/.claude/skills/$name"
     )

     for d in "${candidates[@]}"; do
       if [[ -d "$d" ]]; then
         echo "$d"
         return 0
       fi
     done

     echo "Error: skill '$name' not found in repo-scoped or user-scoped skill dirs." >&2
     return 1
   }

   BESIMPLE_BROCCOLI_BLIND_SKILL_DIR="$(resolve_skill_dir besimple-broccoli-blind)"
   PLAN_SKETCH_SKILL_DIR="$(resolve_skill_dir plan-sketch)"
   PLAN_WRITE_SKILL_DIR="$(resolve_skill_dir plan-write)"
   PLAN_CRITIQUE_LOOP_SKILL_DIR="$(resolve_skill_dir plan-critique-loop)"
   SIMPLIFY_SKILL_DIR="$(resolve_skill_dir claude-simplify-wrapper)"
   DEDUP_SKILL_DIR="$(resolve_skill_dir dedup)"
   CODE_REVIEW_LOOP_SKILL_DIR="$(resolve_skill_dir code-review-loop)"
   ```

1. **Write `IDEA_FILE` from user input**
   - `IDEA_FILE="${LOG_DIR}/idea.md"`
   - Preserve the user message verbatim.

2. **Run `plan-sketch` and auto-select recommended options**
   ```bash
   SKETCH_DOC=$(python3 "$PLAN_SKETCH_SKILL_DIR/scripts/run_plan_sketch.py" --idea-file "${IDEA_FILE}" --output "${LOG_DIR}/sketch.md" --timeout "${SUBAGENT_TIMEOUT_SECONDS}" --progress-log "${SKETCH_LOG}" --heartbeat-seconds "${HEARTBEAT_SECONDS}")
   ```

   Extract the last user-questions block:
   ```bash
   QUESTIONS_BLOCK=$(awk '
     /^BEGIN_USER_QUESTIONS$/ {in_block=1; block=""; next}
     /^END_USER_QUESTIONS$/   {in_block=0; last=block; next}
     in_block                 {block = block $0 ORS}
     END                      {printf "%s", last}
   ' "${SKETCH_LOG}")
   ```

   Auto-pick recommended options by reading `QUESTIONS_BLOCK` directly in the LLM context (no shell/regex parsing):
   - Set `AUTO_SELECTIONS` to a comma-separated list of all labels whose option text ends with `(Recommended)` (for example: `1a, 2c`).
   - Do not compute `AUTO_SELECTIONS` with `awk`, `jq`, or `python`.
   - If no recommended options are present, continue to empty feedback. 

   Save synthetic feedback:
   ```bash
   USER_FEEDBACK_FILE="${LOG_DIR}/user-feedback.md"
   cat > "${USER_FEEDBACK_FILE}" <<'FEEDBACK'
## User feedback (verbatim)
<auto-populated by wrapper>
FEEDBACK
   printf "%s\n" "${AUTO_SELECTIONS}" >> "${USER_FEEDBACK_FILE}"
   ```

   Append to `IDEA_FILE`:
   - Clarification mode: automatic recommended picks
   - Selected labels: `${AUTO_SELECTIONS}`

3. **Create working branch**
   - Ensure clean tree:
     ```bash
     if [ -n "$(git status --porcelain)" ]; then
       echo "Working tree is not clean. Aborting before branch creation." >&2
       exit 1
     fi
     ```
   - Choose `BASE_REF` explicitly:
     - If the user explicitly asked for a base branch/commit in the request, use that.
     - Otherwise, derive the default remote branch:
       ```bash
       DEFAULT_BRANCH="$(git symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null | sed 's#^origin/##')"
       if [ -z "${DEFAULT_BRANCH}" ]; then
         if git show-ref --verify --quiet refs/remotes/origin/main; then DEFAULT_BRANCH=main;
         elif git show-ref --verify --quiet refs/remotes/origin/master; then DEFAULT_BRANCH=master;
         else
           echo "Could not determine origin default branch (origin/HEAD, main, master). Aborting." >&2
           exit 1
         fi
       fi
       BASE_REF="origin/${DEFAULT_BRANCH}"
       ```
   - Choose branch name explicitly from clarified scope:
     - Use `task/` prefix.
     - Build a short slug from the clarified goal in `IDEA_FILE` (letters/numbers/dashes only, concise and specific).
     - Example: `task/auto-select-recommended-options`.
   - Sanitize, avoid collisions, and create the branch:
     ```bash
     BRANCH_NAME_SEED="task/<clarified-scope-slug>"
     BRANCH_NAME="${BRANCH_NAME_SEED}"
     BRANCH_NAME="$(echo "${BRANCH_NAME}" | tr '[:upper:]' '[:lower:]' | sed -E 's@[^a-z0-9._/-]+@-@g; s@/+@/@g; s@^-+@@; s@-+$@@; s@^/+@@; s@/+$@@')"
     if [ -z "${BRANCH_NAME}" ]; then
       echo "Branch name is empty after sanitization. Aborting." >&2
       exit 1
     fi
     BRANCH="${BRANCH_NAME}"
     if git show-ref --verify --quiet "refs/heads/${BRANCH}"; then
       i=2
       while git show-ref --verify --quiet "refs/heads/${BRANCH}-${i}"; do i=$((i+1)); done
       BRANCH="${BRANCH}-${i}"
     fi
     if ! git rev-parse --verify --quiet "${BASE_REF}^{commit}