fix: remove elaborator from construction workflows and improve intent discovery

Elaboration is a separate pre-construction phase (/elaborate), not a
construction hat. Including it in workflows forced construct to work
around it everywhere. This removes the elaborator hat from all workflow
definitions, fallback defaults, and construction logic.

Also improves:
- Elaborate Phase 0 skips completed/in-progress intents (only pending
  intents can be re-elaborated)
- Construct discovers intents from both filesystem AND ai-dlc/* branches
  (not just current directory)
- Workflow selection uses preflight display + AI recommendation before
  user decides, with support for custom hat compositions

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

Author: jwaldrip

plugin/hooks/inject-context.sh

@@ -284,7 +284,7 @@ fi
 
 # Parse iteration state using han parse (no jq needed)
 ITERATION=$(echo "$ITERATION_JSON" | han parse json iteration -r --default 1)
-HAT=$(echo "$ITERATION_JSON" | han parse json hat -r --default elaborator)
+HAT=$(echo "$ITERATION_JSON" | han parse json hat -r --default planner)
 STATUS=$(echo "$ITERATION_JSON" | han parse json status -r --default active)
 WORKFLOW_NAME=$(echo "$ITERATION_JSON" | han parse json workflowName -r --default default)
 
@@ -295,10 +295,10 @@ if ! echo "$KNOWN_WORKFLOWS" | grep -qw "$WORKFLOW_NAME"; then
 fi
 
 # Get workflow hats array as string
-WORKFLOW_HATS=$(echo "$ITERATION_JSON" | han parse json workflow 2>/dev/null || echo '["elaborator","planner","builder","reviewer"]')
+WORKFLOW_HATS=$(echo "$ITERATION_JSON" | han parse json workflow 2>/dev/null || echo '["planner","builder","reviewer"]')
 # Format as arrow-separated list
 WORKFLOW_HATS_STR=$(echo "$WORKFLOW_HATS" | tr -d '[]"' | sed 's/,/ → /g')
-[ -z "$WORKFLOW_HATS_STR" ] && WORKFLOW_HATS_STR="elaborator → planner → builder → reviewer"
+[ -z "$WORKFLOW_HATS_STR" ] && WORKFLOW_HATS_STR="planner → builder → reviewer"
 
 # If task is complete, just show completion message
 if [ "$STATUS" = "complete" ]; then

plugin/hooks/subagent-context.sh

@@ -48,9 +48,9 @@ if [ "$STATUS" = "complete" ] || [ -z "$HAT" ]; then
 fi
 
 # Get workflow hats array as string
-WORKFLOW_HATS=$(echo "$ITERATION_JSON" | han parse json workflow 2>/dev/null || echo '["elaborator","planner","builder","reviewer"]')
+WORKFLOW_HATS=$(echo "$ITERATION_JSON" | han parse json workflow 2>/dev/null || echo '["planner","builder","reviewer"]')
 WORKFLOW_HATS_STR=$(echo "$WORKFLOW_HATS" | tr -d '[]"' | sed 's/,/ → /g')
-[ -z "$WORKFLOW_HATS_STR" ] && WORKFLOW_HATS_STR="elaborator → planner → builder → reviewer"
+[ -z "$WORKFLOW_HATS_STR" ] && WORKFLOW_HATS_STR="planner → builder → reviewer"
 
 # Get intent-slug from han keep (pointer only, not content)
 load_keep_value() {

plugin/lib/dag.sh

@@ -433,7 +433,7 @@ is_dag_complete() {
 
 # Determine recommended starting hat based on unit states
 # Usage: get_recommended_hat <intent_dir> [workflow_name]
-# Returns: hat name (elaborator, planner, builder, reviewer, etc.)
+# Returns: hat name (planner, builder, reviewer, etc.)
 get_recommended_hat() {
   local intent_dir="$1"
   local workflow_name="${2:-default}"
@@ -444,7 +444,7 @@ get_recommended_hat() {
   hats=$(han parse yaml "${workflow_name}.hats" < "$hats_file" 2>/dev/null | sed 's/^- //' | tr '\n' ' ')
 
   # Default hats if parse fails
-  [ -z "$hats" ] && hats="elaborator planner builder reviewer"
+  [ -z "$hats" ] && hats="planner builder reviewer"
 
   # Convert to array
   read -ra hat_array <<< "$hats"

plugin/skills/advance/SKILL.md

@@ -18,7 +18,6 @@ user-invocable: false
 **Internal command** - Called by the AI during `/construct`, not directly by users.
 
 Advances to the next hat in the workflow sequence. For example, in the default workflow:
-- elaborator -> planner (intent defined, now plan the work)
 - planner -> builder (plan ready, now implement)
 - builder -> reviewer (bolt complete, now review)
 
@@ -39,7 +38,7 @@ STATE=$(han keep load iteration.json --quiet)
 ### Step 2: Determine Next Hat (or Handle Completion)
 
 ```javascript
-const workflow = state.workflow || ["elaborator", "planner", "builder", "reviewer"];
+const workflow = state.workflow || ["planner", "builder", "reviewer"];
 const currentIndex = workflow.indexOf(state.hat);
 const nextIndex = currentIndex + 1;
 

plugin/skills/ai-dlc-fundamentals/SKILL.md

@@ -144,13 +144,14 @@ Different phases of work require different mindsets. AI-DLC uses "hats" to forma
 
 ### Default Workflow
 
+Elaboration (`/elaborate`) is a separate pre-construction phase. The construction workflow starts after elaboration is complete:
+
 ```
-elaborator → planner → builder → reviewer
+planner → builder → reviewer
 ```
 
 | Hat | Focus | Mode |
 |-----|-------|------|
-| Elaborator | Define intent and criteria | HITL |
 | Planner | Plan this iteration | HITL |
 | Builder | Implement to spec | OHOTL |
 | Reviewer | Verify quality | HITL |

plugin/skills/construct/SKILL.md

@@ -65,33 +65,64 @@ If truly blocked (cannot proceed without user input):
 
 **CRITICAL: The orchestrator MUST run in the intent worktree, not the main working directory.**
 
-Before loading state, find and switch to the intent worktree:
+Before loading state, discover all active intents from both the filesystem and `ai-dlc/*` branches:
 
 ```bash
-# First, check if we have an intent slug saved (try to find it)
-# Look for .ai-dlc/*/intent.md files to detect intent
-INTENT_SLUG=""
+# Source DAG library for branch discovery
+source "${CLAUDE_PLUGIN_ROOT}/lib/dag.sh"
+
+declare -A ACTIVE_INTENTS  # slug -> "source" (filesystem|worktree|local)
+
+# 1. Check filesystem (current directory)
 for intent_file in .ai-dlc/*/intent.md; do
   [ -f "$intent_file" ] || continue
   dir=$(dirname "$intent_file")
   slug=$(basename "$dir")
-  status=$(han parse yaml status -r --default active < "$intent_file" 2>/dev/null || echo "active")
-  [ "$status" = "active" ] && INTENT_SLUG="$slug" && break
+  status=$(_yaml_get_simple "status" "active" < "$intent_file")
+  [ "$status" = "active" ] && ACTIVE_INTENTS[$slug]="filesystem"
 done
 
-# If we found an intent, ensure we're in its worktree
-if [ -n "$INTENT_SLUG" ]; then
-  INTENT_BRANCH="ai-dlc/${INTENT_SLUG}"
-  INTENT_WORKTREE="/tmp/ai-dlc-${INTENT_SLUG}"
+# 2. Check ai-dlc/* branches (worktrees and local branches)
+while IFS='|' read -r slug workflow source branch; do
+  [ -z "$slug" ] && continue
+  # Don't overwrite filesystem entries (they take display priority)
+  [ -z "${ACTIVE_INTENTS[$slug]}" ] && ACTIVE_INTENTS[$slug]="$source"
+done < <(discover_branch_intents false)
+
+# 3. Handle results
+if [ ${#ACTIVE_INTENTS[@]} -eq 0 ]; then
+  echo "No active AI-DLC intent found."
+  echo ""
+  echo "Run /elaborate to start a new task, or /resume <slug> if you know the intent slug."
+  exit 0
+fi
 
-  # Create worktree if it doesn't exist
-  if [ ! -d "$INTENT_WORKTREE" ]; then
-    git worktree add -B "$INTENT_BRANCH" "$INTENT_WORKTREE"
-  fi
+if [ ${#ACTIVE_INTENTS[@]} -eq 1 ]; then
+  # Single intent — use it
+  INTENT_SLUG="${!ACTIVE_INTENTS[@]}"
+elif [ ${#ACTIVE_INTENTS[@]} -gt 1 ]; then
+  # Multiple intents — ask the user which one to construct
+  echo "Multiple active intents found:"
+  echo ""
+  for slug in "${!ACTIVE_INTENTS[@]}"; do
+    echo "- **$slug** (${ACTIVE_INTENTS[$slug]})"
+  done
+  echo ""
+  # Use AskUserQuestion with the discovered intents as options
+  # (construct will present these dynamically)
+  echo "Use /construct <slug> to specify which intent to build."
+  exit 0
+fi
 
-  # Switch to the intent worktree
-  cd "$INTENT_WORKTREE"
+# Ensure we're in the intent worktree
+INTENT_BRANCH="ai-dlc/${INTENT_SLUG}"
+INTENT_WORKTREE="/tmp/ai-dlc-${INTENT_SLUG}"
+
+if [ ! -d "$INTENT_WORKTREE" ]; then
+  git worktree add -B "$INTENT_BRANCH" "$INTENT_WORKTREE"
 fi
+
+cd "$INTENT_WORKTREE"
 ```
 
 **Important:** The orchestrator runs in `/tmp/ai-dlc-{intent-slug}/`, NOT the original repo directory. This keeps main clean and enables parallel intents.
@@ -179,9 +210,9 @@ Loop over ALL ready units from the DAG (not just one):
 source "${CLAUDE_PLUGIN_ROOT}/lib/dag.sh"
 READY_UNITS=$(find_ready_units "$INTENT_DIR")
 
-# Determine first construction hat (skip "elaborator" if present)
+# Determine first construction hat
 WORKFLOW_HATS=$(echo "$STATE" | han parse json workflow)
-FIRST_HAT=$(echo "$WORKFLOW_HATS" | jq -r '[.[] | select(. != "elaborator")][0]')
+FIRST_HAT=$(echo "$WORKFLOW_HATS" | jq -r '.[0]')
 ```
 
 **Include repo URL for cowork**: If operating in a cloned workspace, include the repo URL in each teammate's prompt: "Repository: `<remote-url>`. Clone and checkout `ai-dlc/<intent-slug>` if you don't have local access." This enables teammates to clone independently in cowork mode.
@@ -420,10 +451,10 @@ fi
 ```
 
 d. Check DAG for newly unblocked units
-e. For each newly ready unit, spawn at `workflow[0]` (first hat, skipping "elaborator" if present -- use the first non-elaborator hat):
+e. For each newly ready unit, spawn at `workflow[0]` (first hat):
 
 ```bash
-FIRST_HAT=$(echo "$WORKFLOW_HATS" | jq -r '[.[] | select(. != "elaborator")][0]')
+FIRST_HAT=$(echo "$WORKFLOW_HATS" | jq -r '.[0]')
 ```
 
 Then follow the same spawn logic from Step 3 (load hat instructions, select agent type, spawn teammate with hat instructions in prompt).
@@ -488,7 +519,7 @@ The `iteration.json` is extended with `unitStates` for parallel hat tracking:
   "hat": "builder",
   "status": "active",
   "workflowName": "default",
-  "workflow": ["elaborator", "planner", "builder", "reviewer"],
+  "workflow": ["planner", "builder", "reviewer"],
   "teamName": "ai-dlc-my-intent",
   "unitStates": {
     "unit-01-foundation": { "hat": "reviewer", "retries": 0 },

plugin/skills/elaborate/SKILL.md

@@ -72,8 +72,11 @@ Before any elaboration, verify the working environment:
 If the user invoked this with a slug argument:
 
 1. Check if `.ai-dlc/{slug}/intent.md` exists
-2. If it exists and no units are completed (all units have `status: pending`):
-   - **Assume the user wants to modify the existing intent**
+2. If it exists, check the intent and unit statuses:
+   - **Skip if intent status is `complete`**: Tell the user "Intent `{slug}` is already completed. Run `/elaborate` without a slug to start a new intent." Then stop.
+   - **Skip if ANY unit has status `in_progress` or `completed`**: Construction has already started — elaboration would conflict with in-flight work. Tell the user "Intent `{slug}` already has units in progress or completed. Use `/resume {slug}` to continue construction or `/construct` to resume the build loop." Then stop.
+   - **Only proceed if ALL units have `status: pending`** (no work has begun yet):
+3. If all units are pending — **assume the user wants to modify the existing intent**:
    - Read ALL files in `.ai-dlc/{slug}/` directory
    - **Display FULL file contents** to the user in markdown code blocks (never summarize or truncate):
      ```
@@ -107,7 +110,7 @@ If the user invoked this with a slug argument:
      }]
    }
    ```
-3. Based on their choice:
+4. Based on their choice:
    - **Modify intent**: Jump to Phase 4 (Success Criteria) with current values pre-filled
    - **Modify units**: Jump to Phase 5 (Decompose) with current units shown
    - **Start fresh**: Delete `.ai-dlc/{slug}/` and proceed to Phase 1
@@ -308,26 +311,63 @@ cat "${CLAUDE_PLUGIN_ROOT}/workflows.yml"
 
 ### Step 3: Select or Compose Workflow
 
-Based on the intent, recommend a workflow from the discovered options. Present available workflows dynamically — do NOT hardcode the options.
+This step has three parts: show what's available, make a recommendation, then let the user decide.
 
-Use `AskUserQuestion` with the discovered workflows as options. Include a "Custom" option that lets the user compose their own hat sequence from the available hats:
+#### 3a. Preflight — Display Available Options
+
+First, show the user all predefined workflows (from Step 2) and available hats (from Step 1) so they have full visibility before any recommendation:
+
+```markdown
+## Available Workflows
+
+{List each predefined workflow with its hat sequence, from Step 2}
+
+## Available Hats
+
+{List each hat with its slug and one-line description, from Step 1}
+```
+
+#### 3b. Recommendation — Suggest the Best Fit
+
+Analyze the intent against the available options. Consider:
+- What phases does this intent actually need? (Not every intent needs planning — a pure refactor might skip straight to builder.)
+- Does the domain suggest specialized hats? (Security-sensitive work benefits from red-team/blue-team. Bug investigations benefit from observer/hypothesizer.)
+- Keep it minimal — every hat adds an iteration cycle. Don't add hats "just in case."
+
+Present your recommendation with reasoning:
+
+```markdown
+## Recommendation
+
+**{workflow name or "Custom"}**: {hats as arrows}
+
+{1-2 sentences explaining why this fits the intent. Reference specific aspects of what the user described.}
+```
+
+The recommendation can be a predefined workflow or a custom composition — whichever best fits. If suggesting a custom sequence, explain what each hat contributes to this specific intent.
+
+#### 3c. User Decides
+
+Use `AskUserQuestion` with the predefined workflows as options. Do NOT hardcode options — use the workflows discovered in Step 2:
 
 ```json
 {
   "questions": [{
-    "question": "Which workflow fits this task? (or compose a custom one from available hats)",
+    "question": "Which workflow would you like to use?",
     "header": "Workflow",
     "options": [
       {"label": "{recommended} (Recommended)", "description": "{hats as arrows}"},
       {"label": "{workflow2}", "description": "{hats as arrows}"},
       {"label": "{workflow3}", "description": "{hats as arrows}"},
-      {"label": "Custom", "description": "Compose a custom hat sequence from available hats"}
+      {"label": "Custom", "description": "Tell me which hats to use and in what order"}
     ],
     "multiSelect": false
   }]
 }
 ```
 
+If your recommendation is a custom composition, include it as the first option with "(Recommended)". The predefined workflows still appear as alternatives.
+
 If the user selects "Custom", ask them to specify which hats to include and in what order.
 
 ---
@@ -770,7 +810,7 @@ Intent-level state is saved to the current branch (which is now the intent branc
 han keep save intent-slug "{intent-slug}"
 
 # Intent-level state -> current branch (intent branch)
-han keep save iteration.json '{"iteration":1,"hat":"{first-hat-after-elaborator}","workflowName":"{workflow}","mode":"{HITL|OHOTL|AHOTL}","workflow":["{hat1}","{hat2}"],"status":"active"}'
+han keep save iteration.json '{"iteration":1,"hat":"{first-hat}","workflowName":"{workflow}","mode":"{HITL|OHOTL|AHOTL}","workflow":["{hat1}","{hat2}"],"status":"active"}'
 ```
 
 ### 5. Commit all artifacts on intent branch:

plugin/skills/fail/SKILL.md

@@ -20,9 +20,8 @@ user-invocable: false
 Goes back to the previous hat in the workflow. Typically used when:
 - Reviewer finds issues -> return to builder
 - Builder hits fundamental blocker -> return to planner
-- Planner realizes requirements unclear -> return to elaborator
 
-If already at the first hat (elaborator by default), this command is blocked.
+If already at the first hat (planner by default), this command is blocked.
 
 ## Implementation
 
@@ -36,13 +35,13 @@ STATE=$(han keep load iteration.json --quiet)
 ### Step 2: Determine Previous Hat
 
 ```javascript
-const workflow = state.workflow || ["elaborator", "planner", "builder", "reviewer"];
+const workflow = state.workflow || ["planner", "builder", "reviewer"];
 const currentIndex = workflow.indexOf(state.hat);
 const prevIndex = currentIndex - 1;
 
 if (prevIndex < 0) {
   // Already at first hat - cannot go back
-  return "Cannot fail before the first hat (elaborator).";
+  return "Cannot fail before the first hat (planner).";
 }
 
 const prevHat = workflow[prevIndex];
@@ -121,9 +120,9 @@ Continuing construction with the previous hat...
 
 ## Guard
 
-If already at the first hat (elaborator by default), output:
+If already at the first hat (planner by default), output:
 ```
-You are at the first hat (elaborator).
+You are at the first hat (planner).
 
-Cannot go back further. Continue elaboration or use `/reset` to start over.
+Cannot go back further. Use `/reset` to start over, or re-elaborate with `/elaborate <slug>`.
 ```

plugin/workflows.yml

@@ -10,7 +10,7 @@
 
 default:
   description: Standard development workflow
-  hats: [elaborator, planner, builder, reviewer]
+  hats: [planner, builder, reviewer]
 
 tdd:
   description: Test-Driven Development (Red-Green-Refactor)