# 1. Check if .envrc already defines NEXUS_PROJECT
if [ -f .envrc ] && grep -q 'NEXUS_PROJECT' .envrc; then
  # Already configured - source it
  source .envrc
  echo "Using NEXUS_PROJECT=$NEXUS_PROJECT from .envrc"
else
  # 2. Get current repo name to match against nexus projects
  REPO_NAME=$(basename $(git rev-parse --show-toplevel 2>/dev/null) 2>/dev/null || basename $PWD)
  
  # 3. List available projects from nexus
  PROJECTS=$(nexus issue list --format json 2>/dev/null | jq -r '.[].project' | sort -u)
  echo "Available nexus projects:"
  echo "$PROJECTS"
  
  # 4. Check if repo name matches a project
  if echo "$PROJECTS" | grep -qx "$REPO_NAME"; then
    SUGGESTED_PROJECT="$REPO_NAME"
    echo "Repo name '$REPO_NAME' matches nexus project"
  else
    SUGGESTED_PROJECT=""
    echo "Repo name '$REPO_NAME' does not match any nexus project"
  fi
fi

export NEXUS_PROJECT="<project-name>"

NEXUS_PROJECT: <project-name>

nexus status || echo "Server not running on port 7001"

nexus issue claim/create/update/complete/release/renew
nexus plan create/show/template
nexus next/status

1. nexus next --claim --format json  # Claim a high-level issue
2. Analyze the issue, explore scope (delegate to explore agent)
3. Create plan if complex (see Plan-First Workflow)
4. Create subtasks: nexus issue create --title "..." --project "..." --parent <parent_id>
5. Delegate each subtask to appropriate subagent
6. Monitor: nexus issue list --parent <parent_id> --format json
7. When all subtasks completed: nexus issue update <parent_id> --status completed

1. CLAIM ISSUE
   nexus issue claim <id>

2. EXPLORE SCOPE
   Delegate to explore agent (very thorough) to understand what's involved

3. CREATE PLAN (if none exists)
   - Get template: nexus plan template <type>
   - Fill in sections: Intent, Direction, Human Notes, Acceptance Criteria
   - Create: nexus plan create --type <type> --for-issue <id> --body -

4. ITERATE WITH HUMAN (feature plans only)
   - Present plan to human and ask for feedback (see Plan Iteration Loop below)
   - Edit plan based on feedback: `nexus plan edit <id>`
   - Re-present until human approves
   - Human approves: `nexus plan update <id> --ready`
   - Verify: `nexus plan show <id> --format json | jq .ready` must be `true`
   - **DO NOT proceed to step 5 until ready=true** (workers will fail to claim)

5. DECOMPOSE INTO SUBTASKS
   Based on exploration + plan direction, create subtasks

6. DELEGATE TO WORKERS
   Each subtask = one delegation to builder agent

7. VERIFY & COMPLETE
   After all subtasks verified, complete parent

# Get template
nexus plan template feature

# Create plan with stdin
cat << 'EOF' | nexus plan create --type feature --for-issue abc123 --body -
## Intent
Add user authentication to protect API endpoints.

## Direction
Use JWT tokens with refresh mechanism. Store hashed passwords in SQLite.

## Human Notes
- Don't use session cookies, we need stateless auth for API
- Password hashing must use bcrypt, not md5/sha

## Acceptance Criteria
- [ ] Users can register and login
- [ ] Protected endpoints reject unauthenticated requests
- [ ] Tokens expire and can be refreshed
EOF

# Check if plan is approved
nexus plan show abc123 --format json | jq .ready

# List all plans awaiting approval
nexus plan list --not-ready

# Check specific plan status
nexus plan show <plan_id> --format json | jq '.ready'

## Plan Created: [plan_id]

**Type**: feature (requires human approval)

### Intent
[paste intent section]

### Direction  
[paste direction section]

### Acceptance Criteria
[paste criteria]

---

Please review this plan. I need your approval before I can decompose this into subtasks.

Options:
1. **Approve as-is**: I'll mark it ready and proceed
2. **Request changes**: Tell me what to modify
3. **Reject**: I'll release the issue for reconsideration

# Open plan in editor for modification
nexus plan edit <plan_id>

# Then re-present to human
nexus plan show <plan_id>

# Check if approved
READY=$(nexus plan show <plan_id> --format json | jq -r '.ready')

if [ "$READY" = "true" ]; then
  echo "Plan approved - proceeding to decomposition"
  # Create subtasks...
else
  echo "Plan not approved - awaiting human feedback"
  # Present plan again or wait
fi

CONTEXT:
- Stack: [technologies in use]
- Constraints: [patterns to follow/avoid]

NEXUS_PROJECT: <project-name>  # REQUIRED - prevents cross-project contamination

SKILLS TO LOAD:
- nexus-worker

NEXUS SUBTASK: <subtask_id>

TASK:
- Set project: export NEXUS_PROJECT="<project-name>"
- Claim the subtask: nexus issue claim <subtask_id>
- [specific implementation task]
- Complete it: nexus issue update <subtask_id> --status completed

# Check subtask status
nexus issue list --parent abc123 --format json

# If all subtasks have status=completed, mark parent done
nexus issue update abc123 --status completed

# Run tests
uv run pytest

# Check linting
uv run ruff check

# Type check (if configured)
uv run mypy

# 1. Claim the feature
nexus issue claim feat-123

# 2. Explore scope (delegate)
# ... explore agent returns analysis ...

# 3. Create subtasks
nexus issue create --parent feat-123 --project nexus --title "Add Levenshtein similarity util"
nexus issue create --parent feat-123 --project nexus --title "Add duplicate_of field to issue schema"
nexus issue create --parent feat-123 --project nexus --title "Add duplicate search endpoint"
nexus issue create --parent feat-123 --project nexus --title "Add duplicate check to CLI create flow"
nexus issue create --parent feat-123 --project nexus --title "Add soft close behavior for duplicates"

# 4. Delegate each (include NEXUS SUBTASK: <id> in prompt)
# ... builders implement ...

# 5. Verify each, then complete parent
nexus issue update feat-123 --status completed