aiblueprint-cli 1.4.24 → 1.4.25

package/claude-code-config/skills/workflow-apex-free/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: apex
+description: Systematic implementation using APEX methodology (Analyze-Plan-Execute-Validate) with parallel agents and self-validation. Use when implementing features, fixing bugs, or making code changes that benefit from structured workflow.
+argument-hint: "[-a] [-s] [-e] [-b] [-i] [-r <task-id>] <task description>"
+---
+
+<objective>
+Execute systematic implementation workflows using the APEX methodology. This skill uses progressive step loading to minimize context usage and supports saving outputs for review and resumption.
+</objective>
+
+<quick_start>
+**Basic usage:**
+
+```bash
+/apex add authentication middleware
+```
+
+**Recommended workflow (autonomous with save):**
+
+```bash
+/apex -a -s implement user registration
+```
+
+**Flags:**
+
+- `-a` (auto): Skip confirmations
+- `-s` (save): Save outputs to `.claude/output/apex/`
+- `-e` (economy): No subagents, save tokens
+
+See `<parameters>` for complete flag list.
+</quick_start>
+
+<parameters>
+
+<flags>
+**Enable flags (turn ON):**
+| Short | Long | Description |
+|-------|------|-------------|
+| `-a` | `--auto` | Autonomous mode: skip confirmations, auto-approve plans |
+| `-s` | `--save` | Save mode: output each step to `.claude/output/apex/` |
+| `-e` | `--economy` | Economy mode: no subagents, save tokens (for limited plans) |
+| `-r` | `--resume` | Resume mode: continue from a previous task |
+| `-b` | `--branch` | Branch mode: verify not on main, create branch if needed |
+| `-i` | `--interactive` | Interactive mode: configure flags via AskUserQuestion |
+
+**Disable flags (turn OFF):**
+| Short | Long | Description |
+|-------|------|-------------|
+| `-A` | `--no-auto` | Disable auto mode |
+| `-S` | `--no-save` | Disable save mode |
+| `-E` | `--no-economy` | Disable economy mode |
+| `-B` | `--no-branch` | Disable branch mode |
+</flags>
+
+<examples>
+```bash
+# Basic
+/apex add auth middleware
+
+# Autonomous (skip confirmations)
+/apex -a add auth middleware
+
+# Save outputs
+/apex -a -s add auth middleware
+
+# Resume previous task
+/apex -r 01-auth-middleware
+/apex -r 01  # Partial match
+
+# Economy mode (save tokens)
+/apex -e add auth middleware
+
+# Interactive flag config
+/apex -i add auth middleware
+
+# Disable flags (uppercase)
+/apex -A add auth middleware  # Disable auto
+```
+</examples>
+
+<parsing_rules>
+**Flag parsing:**
+
+1. Defaults loaded from `steps/step-00-init.md` `<defaults>` section
+2. Command-line flags override defaults (enable with lowercase `-x`, disable with uppercase `-X`)
+3. Flags removed from input, remainder becomes `{task_description}`
+4. Task ID generated as `NN-kebab-case-description`
+
+For detailed parsing algorithm, see `steps/step-00-init.md`.
+</parsing_rules>
+
+</parameters>
+
+<output_structure>
+**When `{save_mode}` = true:**
+
+All outputs saved to PROJECT directory (where Claude Code is running):
+```
+.claude/output/apex/{task-id}/
+├── 00-context.md # Params, user request, timestamp
+├── 01-analyze.md # Analysis findings
+├── 02-plan.md # Implementation plan
+├── 03-execute.md # Execution log
+└── 04-validate.md # Validation results
+```
+
+**00-context.md structure:**
+```markdown
+# APEX Task: {task_id}
+
+**Created:** {timestamp}
+**Task:** {task_description}
+
+## Flags
+- Auto mode: {auto_mode}
+- Save mode: {save_mode}
+- Economy mode: {economy_mode}
+
+## User Request
+{original user input}
+
+## Acceptance Criteria
+- [ ] AC1: {inferred criterion}
+- [ ] AC2: {inferred criterion}
+```
+
+</output_structure>
+
+<resume_workflow>
+**Resume mode (`-r {task-id}`):**
+
+When provided, step-00 will:
+
+1. Locate the task folder in `.claude/output/apex/`
+2. Restore state from `00-context.md`
+3. Find the last completed step
+4. Continue from the next step
+
+Supports partial matching (e.g., `-r 01` finds `01-add-auth-middleware`).
+
+For implementation details, see `steps/step-00-init.md`.
+</resume_workflow>
+
+<workflow>
+**Standard flow:**
+1. Parse flags and task description
+2. If `-r`: Execute resume workflow
+3. If `-s`: Create output folder and 00-context.md
+4. Load step-01-analyze.md → gather context
+5. Load step-02-plan.md → create strategy
+6. Load step-03-execute.md → implement
+7. Load step-04-validate.md → verify and complete
+</workflow>
+
+<state_variables>
+**Persist throughout all steps:**
+
+| Variable                | Type    | Description                                            |
+| ----------------------- | ------- | ------------------------------------------------------ |
+| `{task_description}`    | string  | What to implement (flags removed)                      |
+| `{feature_name}`        | string  | Kebab-case name without number (e.g., `add-auth-middleware`) |
+| `{task_id}`             | string  | Full identifier with number (e.g., `01-add-auth-middleware`) |
+| `{acceptance_criteria}` | list    | Success criteria (inferred or explicit)                |
+| `{auto_mode}`           | boolean | Skip confirmations, use recommended options            |
+| `{save_mode}`           | boolean | Save outputs to .claude/output/apex/                   |
+| `{economy_mode}`        | boolean | No subagents, direct tool usage only                   |
+| `{branch_mode}`         | boolean | Verify not on main, create branch if needed            |
+| `{interactive_mode}`    | boolean | Configure flags interactively                          |
+| `{resume_task}`         | string  | Task ID to resume (if -r provided)                     |
+| `{output_dir}`          | string  | Full path to output directory                          |
+| `{branch_name}`         | string  | Created branch name (if branch_mode)                   |
+
+</state_variables>
+
+<entry_point>
+
+**FIRST ACTION:** Load `steps/step-00-init.md`
+
+Step 00 handles:
+
+- Flag parsing (-a, -x, -s, -r, --test)
+- Resume mode detection and task lookup
+- Output folder creation (if save_mode)
+- 00-context.md creation (if save_mode)
+- State variable initialization
+
+After initialization, step-00 loads step-01-analyze.md.
+
+</entry_point>
+
+<step_files>
+**Progressive loading - only load current step:**
+
+| Step | File                         | Purpose                                              |
+| ---- | ---------------------------- | ---------------------------------------------------- |
+| 00   | `steps/step-00-init.md`      | Parse flags, create output folder, initialize state  |
+| 01   | `steps/step-01-analyze.md`   | Smart context gathering with 1-10 parallel agents based on complexity |
+| 02   | `steps/step-02-plan.md`      | File-by-file implementation strategy                 |
+| 03   | `steps/step-03-execute.md`   | Todo-driven implementation                           |
+| 04   | `steps/step-04-validate.md`  | Self-check, validation, and workflow completion      |
+
+</step_files>
+
+<execution_rules>
+
+- **Load one step at a time** - Only load the current step file
+- **ULTRA THINK** before major decisions
+- **Persist state variables** across all steps
+- **Follow next_step directive** at end of each step
+- **Save outputs** if `{save_mode}` = true (append to step file)
+- **Use parallel agents** for independent exploration tasks
+
+## 🧠 Smart Agent Strategy in Analyze Phase
+
+The analyze phase (step-01) uses **adaptive agent launching** (unless economy_mode):
+
+**Available agents:**
+- `explore-codebase` - Find existing patterns, files, utilities
+- `explore-docs` - Research library docs (use when unfamiliar with API)
+- `websearch` - Find approaches, best practices, gotchas
+
+**Launch 1-10 agents based on task complexity:**
+
+| Complexity | Agents | When |
+|------------|--------|------|
+| Simple | 1-2 | Bug fix, small tweak |
+| Medium | 2-4 | New feature in familiar stack |
+| Complex | 4-7 | Unfamiliar libraries, integrations |
+| Major | 6-10 | Multiple systems, many unknowns |
+
+**BE SMART:** Analyze what you actually need before launching. Don't over-launch for simple tasks, don't under-launch for complex ones.
+
+</execution_rules>
+
+<save_output_pattern>
+**When `{save_mode}` = true:**
+
+Step-00 runs `scripts/setup-templates.sh` to initialize all output files from `templates/` directory.
+
+**Each step then:**
+
+1. Run `scripts/update-progress.sh {task_id} {step_num} {step_name} "in_progress"`
+2. Append findings/outputs to the pre-created step file
+3. Run `scripts/update-progress.sh {task_id} {step_num} {step_name} "complete"`
+
+**Template system benefits:**
+
+- Reduces token usage by ~75% (1,350 tokens saved per workflow)
+- Templates in `templates/` directory (not inline in steps)
+- Scripts handle progress tracking automatically
+- See `templates/README.md` for details
+
+</save_output_pattern>
+
+<success_criteria>
+
+- Each step loaded progressively
+- All validation checks passing
+- Outputs saved if `{save_mode}` enabled
+- Clear completion summary provided
+</success_criteria>

package/claude-code-config/skills/workflow-apex-free/scripts/setup-templates.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+# APEX Template Setup Script
+# Creates output directory structure and initializes template files
+#
+# Usage: setup-templates.sh "feature-name" [other args...]
+# The script auto-generates the task ID with the next available number.
+
+set -e
+
+# Arguments - first arg is now just the feature name (kebab-case)
+FEATURE_NAME="$1"
+TASK_DESCRIPTION="$2"
+AUTO_MODE="${3:-false}"
+SAVE_MODE="${4:-false}"
+ECONOMY_MODE="${5:-false}"
+BRANCH_MODE="${6:-false}"
+INTERACTIVE_MODE="${7:-false}"
+BRANCH_NAME="${8:-}"
+ORIGINAL_INPUT="${9:-}"
+
+# Validate required arguments
+if [[ -z "$FEATURE_NAME" ]]; then
+    echo "Error: FEATURE_NAME is required"
+    exit 1
+fi
+
+if [[ -z "$TASK_DESCRIPTION" ]]; then
+    echo "Error: TASK_DESCRIPTION is required"
+    exit 1
+fi
+
+# Get current timestamp
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+# Use current working directory as project root
+PROJECT_ROOT=$(pwd)
+APEX_OUTPUT_DIR="${PROJECT_ROOT}/.claude/output/apex"
+
+# Create apex output directory if it doesn't exist
+mkdir -p "$APEX_OUTPUT_DIR"
+
+# Find the next available number
+NEXT_NUM=1
+if [[ -d "$APEX_OUTPUT_DIR" ]]; then
+    # Find highest existing number prefix
+    HIGHEST=$(ls -1 "$APEX_OUTPUT_DIR" 2>/dev/null | grep -oE '^[0-9]+' | sort -n | tail -1)
+    if [[ -n "$HIGHEST" ]]; then
+        # Force base-10 interpretation (leading zeros would be treated as octal)
+        NEXT_NUM=$((10#$HIGHEST + 1))
+    fi
+fi
+
+# Format with leading zeros (2 digits)
+TASK_NUM=$(printf "%02d" "$NEXT_NUM")
+
+# Build full task ID
+TASK_ID="${TASK_NUM}-${FEATURE_NAME}"
+
+OUTPUT_DIR="${APEX_OUTPUT_DIR}/${TASK_ID}"
+
+# Get skill directory
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TEMPLATE_DIR="${SKILL_DIR}/templates"
+
+# Create output directory
+mkdir -p "$OUTPUT_DIR"
+
+# Function to replace template variables
+render_template() {
+    local template_file="$1"
+    local output_file="$2"
+
+    # Read template and replace variables
+    sed -e "s|{{task_id}}|${TASK_ID}|g" \
+        -e "s|{{task_description}}|${TASK_DESCRIPTION}|g" \
+        -e "s|{{timestamp}}|${TIMESTAMP}|g" \
+        -e "s|{{auto_mode}}|${AUTO_MODE}|g" \
+        -e "s|{{save_mode}}|${SAVE_MODE}|g" \
+        -e "s|{{economy_mode}}|${ECONOMY_MODE}|g" \
+        -e "s|{{branch_mode}}|${BRANCH_MODE}|g" \
+        -e "s|{{interactive_mode}}|${INTERACTIVE_MODE}|g" \
+        -e "s|{{branch_name}}|${BRANCH_NAME}|g" \
+        -e "s|{{original_input}}|${ORIGINAL_INPUT}|g" \
+        "$template_file" > "$output_file"
+}
+
+# Initialize 00-context.md
+render_template "${TEMPLATE_DIR}/00-context.md" "${OUTPUT_DIR}/00-context.md"
+
+# Initialize other step files (only headers, content appended during execution)
+render_template "${TEMPLATE_DIR}/01-analyze.md" "${OUTPUT_DIR}/01-analyze.md"
+render_template "${TEMPLATE_DIR}/02-plan.md" "${OUTPUT_DIR}/02-plan.md"
+render_template "${TEMPLATE_DIR}/03-execute.md" "${OUTPUT_DIR}/03-execute.md"
+render_template "${TEMPLATE_DIR}/04-validate.md" "${OUTPUT_DIR}/04-validate.md"
+
+# Output the generated task_id for capture by caller
+echo "TASK_ID=${TASK_ID}"
+echo "OUTPUT_DIR=${OUTPUT_DIR}"
+echo "✓ APEX templates initialized: ${OUTPUT_DIR}"
+exit 0

package/claude-code-config/skills/workflow-apex-free/scripts/update-progress.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+# APEX Progress Update Script
+# Updates 00-context.md progress table
+
+set -e
+
+# Arguments
+TASK_ID="$1"
+STEP_NUMBER="$2"
+STEP_NAME="$3"
+STATUS="$4"  # "in_progress" or "complete"
+
+# Validate required arguments
+if [[ -z "$TASK_ID" ]] || [[ -z "$STEP_NUMBER" ]] || [[ -z "$STEP_NAME" ]] || [[ -z "$STATUS" ]]; then
+    echo "Usage: $0 <task_id> <step_number> <step_name> <status>"
+    echo "Example: $0 01-add-auth 01 analyze complete"
+    exit 1
+fi
+
+# Find project root
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CONTEXT_FILE="${PROJECT_ROOT}/.claude/output/apex/${TASK_ID}/00-context.md"
+
+# Validate context file exists
+if [[ ! -f "$CONTEXT_FILE" ]]; then
+    echo "Error: Context file not found: $CONTEXT_FILE"
+    exit 1
+fi
+
+# Get timestamp
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+# Determine status symbol
+if [[ "$STATUS" == "in_progress" ]]; then
+    STATUS_SYMBOL="⏳ In Progress"
+elif [[ "$STATUS" == "complete" ]]; then
+    STATUS_SYMBOL="✓ Complete"
+else
+    echo "Error: Invalid status. Use 'in_progress' or 'complete'"
+    exit 1
+fi
+
+# Create temp file
+TEMP_FILE=$(mktemp)
+
+# Update the progress table
+awk -v step="${STEP_NUMBER}-${STEP_NAME}" \
+    -v status="$STATUS_SYMBOL" \
+    -v timestamp="$TIMESTAMP" '
+BEGIN { in_table = 0; found = 0 }
+{
+    # Detect progress table start
+    if ($0 ~ /^## Progress/) {
+        in_table = 1
+        print $0
+        next
+    }
+
+    # If in table and found the matching step
+    if (in_table && $0 ~ "\\| " step " \\|") {
+        printf "| %s | %s | %s |\n", step, status, timestamp
+        found = 1
+        next
+    }
+
+    # Print line as-is
+    print $0
+}
+END {
+    if (!found) {
+        print "Warning: Step not found in progress table" > "/dev/stderr"
+    }
+}
+' "$CONTEXT_FILE" > "$TEMP_FILE"
+
+# Replace original file
+mv "$TEMP_FILE" "$CONTEXT_FILE"
+
+echo "✓ Progress updated: ${STEP_NUMBER}-${STEP_NAME} → ${STATUS_SYMBOL}"
+exit 0

package/claude-code-config/skills/workflow-apex-free/steps/step-00-init.md

@@ -0,0 +1,267 @@
+---
+name: step-00-init
+description: Initialize APEX workflow - parse flags, detect continuation, setup state
+next_step: steps/step-01-analyze.md
+---
+
+# Step 0: Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER skip flag parsing
+- 🛑 ONLY check for existing workflow if resume_task is set
+- ✅ ALWAYS parse ALL flags before any other action
+- ✅ ONLY check for resume if {resume_task} is set
+- 📋 YOU ARE AN INITIALIZER, not an executor
+- 💬 FOCUS on setup only - don't look ahead to implementation
+- 🚫 FORBIDDEN to load step-01 until init is complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Parse flags first, then check resume, then setup
+- 💾 Create output structure if save_mode enabled
+- 📖 Initialize all state variables before proceeding
+- 🚫 FORBIDDEN to start analysis (that's step-01's job)
+- ✅ ALWAYS show COMPACT summary (one table) and proceed immediately
+- 🚫 FORBIDDEN to show verbose parsing logs or explanations
+
+## CONTEXT BOUNDARIES:
+
+- This is the FIRST step - no previous context exists
+- User input contains flags and task description
+- Output folder may or may not exist
+- Don't assume anything about the codebase yet
+
+## YOUR TASK:
+
+Initialize the APEX workflow by parsing flags, detecting continuation state, and setting up the execution environment.
+
+---
+
+<defaults>
+## Default Configuration
+
+**Edit these values to change default behavior. Flags always override defaults.**
+
+```yaml
+# ===========================================
+# APEX DEFAULT SETTINGS
+# ===========================================
+
+auto_mode: false # -a: Skip confirmations, use recommended options
+save_mode: false # -s: Save outputs to .claude/output/apex/
+economy_mode: false # -e: No subagents, save tokens (for limited plans)
+branch_mode: false # -b: Verify not on main, create branch if needed
+interactive_mode: false # -i: Configure flags interactively
+
+# Presets:
+# Budget-friendly:  economy_mode: true
+# Full quality:     save_mode: true
+# Autonomous:       auto_mode: true, save_mode: true
+```
+
+**Flag Reference:** See `SKILL.md` for complete flag documentation and examples.
+
+</defaults>
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Parse Flags and Input
+
+**Step 1: Load defaults from config above**
+
+```
+{auto_mode}    = <default>
+{save_mode}    = <default>
+{economy_mode} = <default>
+{branch_mode}  = <default>
+{interactive_mode} = <default>
+```
+
+**Step 2: Parse user input and override defaults:**
+
+```
+Enable flags (lowercase - turn ON):
+  -a or --auto     → {auto_mode} = true
+  -s or --save     → {save_mode} = true
+  -e or --economy  → {economy_mode} = true
+  -b or --branch   → {branch_mode} = true
+
+Disable flags (UPPERCASE - turn OFF):
+  -A or --no-auto         → {auto_mode} = false
+  -S or --no-save         → {save_mode} = false
+  -E or --no-economy      → {economy_mode} = false
+  -B or --no-branch       → {branch_mode} = false
+
+Interactive:
+  -i or --interactive   → {interactive_mode} = true
+
+Other:
+  -r or --resume   → {resume_task} = <next argument>
+  Remainder        → {task_description}
+```
+
+**Step 3: Generate feature_name and task_id:**
+
+```
+{feature_name} = kebab-case-description (without number prefix)
+
+Example: "add user authentication" → "add-user-authentication"
+
+{task_id} will be generated by the setup script:
+  - Script auto-detects next available number in .claude/output/apex/
+  - Result: "01-add-user-authentication" (or 02, 03, etc.)
+```
+
+### 2. Check Resume Mode
+
+<critical>
+ONLY execute this section if {resume_task} is set!
+If {resume_task} is NOT set, skip directly to step 3.
+</critical>
+
+**If `{resume_task}` is set:**
+
+1. **Search for matching task:**
+
+   ```bash
+   ls .claude/output/apex/ | grep "^{resume_task}"
+   ```
+
+2. **If exact match found:**
+   - Read `00-context.md` to restore state variables
+   - Scan step files to find last completed step (check for completion marker)
+   - Load next incomplete step
+   - **STOP** - do not continue with fresh init
+
+3. **If partial match (e.g., `-r 01`):**
+   - If single match: use it
+   - If multiple matches: list them and ask user to specify
+
+4. **If no match found:**
+   - List available tasks
+   - Ask user to provide correct ID
+
+**If {resume_task} is NOT set:** → Skip directly to step 3
+
+### 3. Run Optional Sub-Steps
+
+**Load sub-steps in order (if flags enabled):**
+
+```
+IF {interactive_mode} = true:
+  → Load steps/step-00b-interactive.md
+  → User configures flags interactively
+  → Return here with updated flags
+
+IF {branch_mode} = true:
+  → Load steps/step-00b-branch.md
+  → Verify/create branch
+  → Return here with {branch_name} set
+
+IF {economy_mode} = true:
+  → Load steps/step-00b-economy.md
+  → Apply economy overrides
+```
+
+### 4. Create Output Structure (if save_mode)
+
+**If `{save_mode}` = true:**
+
+Run the template setup script to initialize all output files:
+
+```bash
+bash {skill_dir}/scripts/setup-templates.sh \
+  "{feature_name}" \
+  "{task_description}" \
+  "{auto_mode}" \
+  "{save_mode}" \
+  "{economy_mode}" \
+  "{branch_mode}" \
+  "{interactive_mode}" \
+  "{branch_name}" \
+  "{original_input}"
+```
+
+**Note:** Pass `{feature_name}` (without number prefix), NOT `{task_id}`.
+The script auto-detects the next available number from existing folders.
+
+This script:
+
+- Auto-generates `{task_id}` = `NN-{feature_name}` (next available number)
+- Creates `.claude/output/apex/{task_id}/` directory
+- Initializes `00-context.md` with configuration and progress table
+- Pre-creates all step files from templates (01-analyze.md, 02-plan.md, etc.)
+- Outputs the generated `{task_id}` for use in subsequent steps
+
+### 5. Initialize and Proceed
+
+**Always (regardless of auto_mode):**
+
+Show COMPACT initialization summary (one table, then proceed immediately):
+
+```
+✓ APEX: {task_description}
+
+| Variable | Value |
+|----------|-------|
+| `{task_id}` | 01-kebab-name |
+| `{auto_mode}` | true/false |
+| `{save_mode}` | true/false |
+| `{economy_mode}` | true/false |
+| `{branch_mode}` | true/false |
+
+→ Analyzing...
+```
+
+<critical>
+KEEP OUTPUT MINIMAL:
+- One line header with task
+- One table with ALL variables (use brackets to show they're available)
+- One line "→ Analyzing..." then IMMEDIATELY load step-01
+- NO verbose explanations, NO parsing logs, NO separators
+</critical>
+
+**Then proceed directly to step-01-analyze.md**
+
+---
+
+## SUCCESS METRICS:
+
+✅ All flags correctly parsed (enable AND disable)
+✅ Output is COMPACT (one table, no verbose logs)
+✅ Variables shown with `{brackets}` notation
+✅ Proceeded to step-01 immediately after table
+✅ Output folder created with 00-context.md (if save_mode)
+
+## FAILURE MODES:
+
+❌ Verbose output with separators and explanations
+❌ Showing parsing steps/logs to user
+❌ Not using `{variable}` bracket notation
+❌ Not proceeding immediately after summary
+❌ **CRITICAL**: Blocking workflow with unnecessary confirmations
+
+## INITIALIZATION PROTOCOLS:
+
+- Parse ALL flags before any other action
+- Check resume BEFORE creating new output folder
+- Verify branch BEFORE creating output structure (if branch_mode)
+- Create output structure BEFORE confirming start
+- Load economy overrides BEFORE proceeding to step-01
+
+---
+
+## NEXT STEP:
+
+After showing initialization summary, always proceed directly to `./step-01-analyze.md`
+
+<critical>
+Remember:
+- Step-00 is an INITIALIZER, not a GATEKEEPER
+- Output MUST be compact: one table, no verbose logs
+- Use `{variable}` notation to show available state
+- Proceed immediately - never block!
+</critical>