~/.claude/skills/planner/planner.nu

P="$HOME/.claude/skills/planner/planner.nu"
nu $P plan --description-file /tmp/plan-desc.md
nu $P validate --bead-id intent-cli-a1b2
nu $P status

PLANNER_DETERMINISTIC(user_input, planner_script):

  # PHASE 0: Initialize planning session
  nu $P init --session-id <id>

  # PHASE 1: Parse user input (AI + deterministic)
  # AI: Read user description, understand requirements
  # Script: Extract sections and structure

  requirements = AI_analyze_requirements(user_input)
  nu $P set-requirements <session-id> <requirements.json>

  # PHASE 2: Decompose into atomic tasks (AI)
  # AI generates list of atomic beads needed
  tasks = AI_decompose_into_beads(requirements)

  for task in tasks:
    nu $P add-task <session-id> <task.json>

  # PHASE 3: Generate beads (deterministic)
  # For each task, expand to full 16-section template
  for task in session.tasks:
    bead_yaml = expand_template(task)
    nu $P generate-bead <session-id> <task-id>

  # PHASE 4: Validate beads (deterministic)
  for bead in session.beads:
    # Validate against CUE schema
    cue_result = cue vet schema/enhanced-bead.cue <bead.cue>
    if cue_result.exit_code != 0:
      # Validation failed - report errors
      nu $P mark-invalid <session-id> <bead-id> <error>
    else:
      nu $P mark-valid <session-id> <bead-id>

  # PHASE 5: Create beads in database (deterministic)
  for valid_bead in session.valid_beads:
    br create --title <bead.title> \
              --type <bead.type> \
              --priority <bead.priority> \
              --description <bead.full_yaml>

    nu $P mark-created <session-id> <bead-id> <br-id>

  # PHASE 6: Report results
  nu $P report <session-id>

UNINITIALIZED → init → REQUIREMENTS_PENDING
  → set-requirements → DECOMPOSITION_PENDING
  → add-task (repeat) → GENERATION_PENDING
  → generate-bead (repeat) → VALIDATION_PENDING
  → validate (all beads) → CREATION_PENDING
  → create (all valid beads) → COMPLETE

# Initialize a new planning session
nu $P init --session-id my-feature --description "Add user authentication"

# Set parsed requirements
nu $P set-requirements my-feature requirements.json

# Add atomic task to session
nu $P add-task my-feature task.json

# Generate bead YAML from task
nu $P generate-bead my-feature task-001

# Validate bead against CUE schema
nu $P validate my-feature task-001

# Create bead in br database
nu $P create my-feature task-001

# Process entire session (generate, validate, create all)
nu $P process my-feature

# Show session status
nu $P status my-feature

# Report session results
nu $P report my-feature

# List all planning sessions
nu $P list

# Reset/clear session
nu $P reset my-feature

# Show all tasks in session
nu $P show-tasks my-feature

# Show generated bead YAML
nu $P show-bead my-feature task-001

# Show validation errors
nu $P show-errors my-feature

# Show created bead IDs
nu $P show-created my-feature

P="$HOME/.claude/skills/planner/planner.nu"

# Create session
nu $P init --session-id user-auth --description "$(cat <<'EOF'
Add JWT-based user authentication to the CLI.

Requirements:
- Login command with username/password
- Token storage in keyring
- Automatic token refresh
- Logout command
- Token validation on all API calls
EOF
)"

[
  {
    "id": "task-001",
    "title": "auth: Add login command with JWT token retrieval",
    "type": "feature",
    "priority": 1,
    "effort": "2hr",
    "description": "Implement login command that accepts credentials and retrieves JWT token",
    "contracts": {
      "preconditions": ["Network connectivity", "Valid API endpoint"],
      "postconditions": ["Token stored in keyring", "User logged in"],
      "invariants": ["Password never logged", "Token encrypted at rest"]
    },
    "tests": {
      "happy": ["Login with valid credentials succeeds"],
      "error": ["Login with invalid credentials returns exit 3", "Login without network returns exit 5"]
    }
  },
  {
    "id": "task-002",
    "title": "auth: Add token storage using system keyring",
    "type": "feature",
    "priority": 1,
    "effort": "1hr",
    ...
  }
]

# Process entire session (AI provides task JSONs first)
echo '$task_json_1' | nu $P add-task user-auth -
echo '$task_json_2' | nu $P add-task user-auth -

# Generate, validate, create all beads
nu $P process user-auth

# Check results
nu $P report user-auth

# Show created beads
nu $P show-created user-auth

# Each bead is now in br database:
br list --filter "auth:"

{
  "id": "task-XXX",
  "title": "component: action description",
  "type": "feature|bug|task|epic|chore",
  "priority": 0-4,
  "effort": "15min|30min|1hr|2hr|4hr",
  "description": "detailed description",
  "clarifications": {
    "resolved": [],
    "open": [],
    "assumptions": []
  },
  "ears": {
    "ubiquitous": ["THE SYSTEM SHALL ..."],
    "event_driven": [{"trigger": "WHEN ...", "shall": "THE SYSTEM SHALL ..."}],
    "unwanted": [{"condition": "IF ...", "shall_not": "THE SYSTEM SHALL NOT ...", "because": "..."}]
  },
  "contracts": {
    "preconditions": ["..."],
    "postconditions": ["..."],
    "invariants": ["..."]
  },
  "tests": {
    "happy": ["test scenario..."],
    "error": ["error scenario..."],
    "edge": ["edge case..."]
  },
  "research": {
    "files": ["path/to/file.rs"],
    "patterns": ["existing pattern to find"],
    "questions": ["what to research?"]
  },
  "implementation": {
    "phase_0": ["research task..."],
    "phase_1": ["test task..."],
    "phase_2": ["implementation task..."]
  },
  "context": {
    "related_files": ["path/to/file"],
    "similar": ["reference to similar code"]
  }
}

session_id: user-auth
description: "Add JWT-based user authentication..."
created_at: "2026-01-31T12:00:00"
status: COMPLETE
tasks:
  task-001:
    title: "auth: Add login command..."
    status: CREATED
    bead_id: intent-cli-a1b2
  task-002:
    title: "auth: Add token storage..."
    status: CREATED
    bead_id: intent-cli-a1b3
summary:
  total_tasks: 2
  generated: 2
  valid: 2
  created: 2
  failed: 0