# pipeline-stages-intake.sh — intake, plan, design stages # Source from pipeline-stages.sh. Requires all pipeline globals and dependencies. [[ -n "${_PIPELINE_STAGES_INTAKE_LOADED:-}" ]] && return 0 _PIPELINE_STAGES_INTAKE_LOADED=1 # Load intent analysis module for acceptance criteria generation SCRIPT_DIR="${SCRIPT_DIR:-$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)}" source "${SCRIPT_DIR}/lib/intent-analysis.sh" 2>/dev/null || true stage_intake() { CURRENT_STAGE_ID="intake" local project_lang project_lang=$(detect_project_lang) info "Project: ${BOLD}$project_lang${RESET}" # 1. Fetch issue metadata if --issue provided if [[ -n "$ISSUE_NUMBER" ]]; then local meta meta=$(gh_get_issue_meta "$ISSUE_NUMBER") # Validate JSON before processing if [[ -n "$meta" ]] && jq empty <<< "$meta" 2>/dev/null; then GOAL=$(echo "$meta" | jq -r '.title // ""' 2>/dev/null) || GOAL="" ISSUE_BODY=$(echo "$meta" | jq -r '.body // ""' 2>/dev/null) || ISSUE_BODY="" ISSUE_LABELS=$(echo "$meta" | jq -r '[.labels[].name] | join(",")' 2>/dev/null) || ISSUE_LABELS="" ISSUE_MILESTONE=$(echo "$meta" | jq -r '.milestone.title // ""' 2>/dev/null || true) ISSUE_ASSIGNEES=$(echo "$meta" | jq -r '[.assignees[].login] | join(",")' 2>/dev/null || true) [[ "$ISSUE_MILESTONE" == "null" ]] && ISSUE_MILESTONE="" [[ "$ISSUE_LABELS" == "null" ]] && ISSUE_LABELS="" # Export for use by intelligence skip functions export ISSUE_LABELS else # Fallback: just get title GOAL=$(gh issue view "$ISSUE_NUMBER" --json title --jq '.title' 2>/dev/null) || { error "Failed to fetch issue #$ISSUE_NUMBER" return 1 } fi GITHUB_ISSUE="#$ISSUE_NUMBER" info "Issue #$ISSUE_NUMBER: ${BOLD}$GOAL${RESET}" if [[ -n "$ISSUE_LABELS" ]]; then info "Labels: ${DIM}$ISSUE_LABELS${RESET}" fi if [[ -n "$ISSUE_MILESTONE" ]]; then info "Milestone: ${DIM}$ISSUE_MILESTONE${RESET}" fi # Self-assign gh_assign_self "$ISSUE_NUMBER" # Add in-progress label gh_add_labels "$ISSUE_NUMBER" "pipeline/in-progress" # 1a. Generate acceptance criteria from issue intent analysis if type analyze_intent >/dev/null 2>&1; then info "Analyzing issue intent and generating acceptance criteria..." if analyze_intent "$GOAL" "$ISSUE_BODY" "$ISSUE_LABELS" "$ARTIFACTS_DIR" 2>/dev/null; then local criteria_preview criteria_preview=$(format_acceptance_criteria_for_prompt "$ARTIFACTS_DIR" 2>/dev/null | head -10 || true) if [[ -n "$criteria_preview" ]]; then info "Acceptance criteria generated: ${DIM}acceptance-criteria.json${RESET}" fi fi fi fi # 2. Detect task type TASK_TYPE=$(detect_task_type "$GOAL") local suggested_template suggested_template=$(template_for_type "$TASK_TYPE") info "Detected: ${BOLD}$TASK_TYPE${RESET} → team template: ${CYAN}$suggested_template${RESET}" # 3. Auto-detect test command if not provided if [[ -z "$TEST_CMD" ]]; then TEST_CMD=$(detect_test_cmd) if [[ -n "$TEST_CMD" ]]; then info "Auto-detected test: ${DIM}$TEST_CMD${RESET}" fi fi # 4. Create branch with smart prefix local prefix prefix=$(branch_prefix_for_type "$TASK_TYPE") local slug slug=$(echo "$GOAL" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | cut -c1-40) slug="${slug%-}" [[ -n "$ISSUE_NUMBER" ]] && slug="${slug}-${ISSUE_NUMBER}" GIT_BRANCH="${prefix}/${slug}" git checkout -b "$GIT_BRANCH" 2>/dev/null || { info "Branch $GIT_BRANCH exists, checking out" git checkout "$GIT_BRANCH" 2>/dev/null || true } success "Branch: ${BOLD}$GIT_BRANCH${RESET}" # 5. Post initial progress comment on GitHub issue if [[ -n "$ISSUE_NUMBER" ]]; then local body body=$(gh_build_progress_body) gh_post_progress "$ISSUE_NUMBER" "$body" fi # 6. Save artifacts save_artifact "intake.json" "$(jq -n \ --arg goal "$GOAL" --arg type "$TASK_TYPE" \ --arg template "$suggested_template" --arg branch "$GIT_BRANCH" \ --arg issue "${GITHUB_ISSUE:-}" --arg lang "$project_lang" \ --arg test_cmd "${TEST_CMD:-}" --arg labels "${ISSUE_LABELS:-}" \ --arg milestone "${ISSUE_MILESTONE:-}" --arg body "${ISSUE_BODY:-}" \ '{goal:$goal, type:$type, template:$template, branch:$branch, issue:$issue, language:$lang, test_cmd:$test_cmd, labels:$labels, milestone:$milestone, body:$body}' 2>/dev/null)" || true # 7. AI-powered skill analysis (replaces static classification when available) if type skill_analyze_issue >/dev/null 2>&1; then local _intel_json="" [[ -f "$ARTIFACTS_DIR/intelligence-analysis.json" ]] && _intel_json=$(cat "$ARTIFACTS_DIR/intelligence-analysis.json" 2>/dev/null || true) if skill_analyze_issue "$GOAL" "${ISSUE_BODY:-}" "${ISSUE_LABELS:-}" "$ARTIFACTS_DIR" "$_intel_json" 2>/dev/null; then info "Skill analysis: AI-powered skill plan written to skill-plan.json" # INTELLIGENCE_ISSUE_TYPE and INTELLIGENCE_COMPLEXITY are updated by skill_analyze_issue else info "Skill analysis: LLM unavailable — using label-based classification" fi fi # 8. Generate structured specification (dark factory: spec-driven development) if type spec_generate >/dev/null 2>&1; then SPEC_DIR="${ARTIFACTS_DIR}/specs" local spec_file spec_file=$(spec_generate "$GOAL" "${ISSUE_BODY:-}" "${ISSUE_NUMBER:-}" "" "$project_lang" 2>/dev/null) || true if [[ -n "$spec_file" && -f "$spec_file" ]]; then info "Spec generated: ${DIM}$(basename "$spec_file")${RESET}" save_artifact "spec.json" "$(cat "$spec_file")" || true fi fi # 9. Partition tests for holdout validation (dark factory: test-as-holdout) if type holdout_partition >/dev/null 2>&1; then HOLDOUT_DIR="${ARTIFACTS_DIR}/test-holdout" if holdout_partition "." "$project_lang" 2>/dev/null; then holdout_seal "." 2>/dev/null || true info "Test holdout: ${HOLDOUT_VISIBLE_COUNT:-0} visible, ${HOLDOUT_SEALED_COUNT:-0} sealed" fi fi log_stage "intake" "Goal: $GOAL Type: $TASK_TYPE → template: $suggested_template Branch: $GIT_BRANCH Language: $project_lang Test cmd: ${TEST_CMD:-none detected} Issue type: ${INTELLIGENCE_ISSUE_TYPE:-backend}" } # ─── Spec Generation Stage (dark factory: spec-driven development) ────────── # Runs between intake and plan. Enhances auto-generated spec with Claude, # adding missing acceptance criteria, edge cases, security requirements, # and affected files estimation. stage_spec_generation() { CURRENT_STAGE_ID="spec_generation" # Check if spec-driven is disabled via env or daemon config if [[ "${SPEC_DRIVEN_ENABLED:-true}" == "false" ]]; then info "Spec-driven development disabled — skipping spec generation" return 0 fi local spec_file="${ARTIFACTS_DIR}/spec.json" # If no spec was generated at intake, generate a basic one now if [[ ! -f "$spec_file" ]]; then if type spec_generate >/dev/null 2>&1 && [[ -n "${GOAL:-}" ]]; then local project_lang project_lang=$(detect_project_lang 2>/dev/null || echo "unknown") SPEC_DIR="${ARTIFACTS_DIR}/specs" local generated generated=$(spec_generate "$GOAL" "${ISSUE_BODY:-}" "${ISSUE_NUMBER:-}" "" "$project_lang" 2>/dev/null) || true if [[ -n "$generated" && -f "$generated" ]]; then save_artifact "spec.json" "$(cat "$generated")" || true spec_file="${ARTIFACTS_DIR}/spec.json" fi fi fi if [[ ! -f "$spec_file" ]]; then warn "No spec available — skipping spec generation enhancement" log_stage "spec_generation" "Skipped: no spec available" return 0 fi # Enhance spec with Claude if available if command -v claude >/dev/null 2>&1; then info "Enhancing specification with AI analysis..." local current_spec current_spec=$(cat "$spec_file") local enhance_prompt="You are a specification analyst. Given the following auto-generated specification and issue context, enhance it by: 1. Adding missing acceptance criteria (each must have 'criterion', 'testable' (bool), and 'verification_method' fields) 2. Adding edge cases (each must have 'scenario' and 'expected_behavior' fields) 3. Adding security requirements (list of strings) 4. Estimating affected files (list of file path strings) Return ONLY valid JSON matching the same schema as the input spec. Do not add commentary. ## Current Spec ${current_spec} ## Issue Context Goal: ${GOAL:-} Body: ${ISSUE_BODY:-} Labels: ${ISSUE_LABELS:-} " local enhanced_spec="" local spec_model="${MODEL:-sonnet}" enhanced_spec=$(claude -p "$enhance_prompt" --model "$spec_model" --output-format json 2>/dev/null) || true if [[ -n "$enhanced_spec" ]]; then # Validate the enhanced spec is valid JSON with required fields if echo "$enhanced_spec" | jq -e '.version and .title and .goals' >/dev/null 2>&1; then # Preserve metadata from original, update timestamp enhanced_spec=$(echo "$enhanced_spec" | jq --arg ts "$(now_iso)" ' .metadata.enhanced_at = $ts | .metadata.enhanced = true ' 2>/dev/null) || enhanced_spec="" if [[ -n "$enhanced_spec" ]]; then save_artifact "spec.json" "$enhanced_spec" || true success "Spec enhanced with AI analysis" fi else warn "AI-enhanced spec failed validation — keeping original" fi else info "Claude unavailable or returned empty — keeping original spec" fi else info "Claude CLI not available — keeping original spec" fi # Validate final spec if type spec_validate >/dev/null 2>&1; then if ! spec_validate "$spec_file" 2>/dev/null; then warn "Spec validation failed after enhancement" # Retry: regenerate from scratch if validation failed if type spec_generate >/dev/null 2>&1 && [[ -n "${GOAL:-}" ]]; then info "Retrying spec generation from scratch..." local project_lang project_lang=$(detect_project_lang 2>/dev/null || echo "unknown") SPEC_DIR="${ARTIFACTS_DIR}/specs" local regen regen=$(spec_generate "$GOAL" "${ISSUE_BODY:-}" "${ISSUE_NUMBER:-}" "" "$project_lang" 2>/dev/null) || true if [[ -n "$regen" && -f "$regen" ]]; then save_artifact "spec.json" "$(cat "$regen")" || true success "Spec regenerated successfully" fi fi fi fi # Count spec richness for logging local criteria_count edge_count security_count affected_count criteria_count=$(jq '.acceptance_criteria | length' "$spec_file" 2>/dev/null || echo "0") edge_count=$(jq '.edge_cases | length' "$spec_file" 2>/dev/null || echo "0") security_count=$(jq '.security_requirements | length' "$spec_file" 2>/dev/null || echo "0") affected_count=$(jq '.affected_files | length' "$spec_file" 2>/dev/null || echo "0") emit_event "spec_generation.completed" \ "issue=${ISSUE_NUMBER:-0}" \ "criteria=$criteria_count" \ "edge_cases=$edge_count" \ "security=$security_count" \ "affected_files=$affected_count" log_stage "spec_generation" "Spec: ${criteria_count} criteria, ${edge_count} edge cases, ${security_count} security reqs, ${affected_count} affected files" } stage_plan() { CURRENT_STAGE_ID="plan" # Consume retry context if this is a retry attempt local _retry_ctx="${ARTIFACTS_DIR}/.retry-context-plan.md" local _retry_hints="" if [[ -s "$_retry_ctx" ]]; then _retry_hints=$(cat "$_retry_ctx" 2>/dev/null || true) rm -f "$_retry_ctx" # consumed fi local plan_file="$ARTIFACTS_DIR/plan.md" if ! command -v claude >/dev/null 2>&1; then error "Claude CLI not found — cannot generate plan" return 1 fi info "Generating implementation plan..." # Dark factory: inject RL approach suggestions based on past episodes if type rl_suggest_approach >/dev/null 2>&1; then local _rl_lang="${INTELLIGENCE_LANGUAGE:-unknown}" local _rl_complexity="${INTELLIGENCE_COMPLEXITY:-medium}" local _rl_type="${INTELLIGENCE_ISSUE_TYPE:-feature}" local _rl_suggestions _rl_suggestions=$(rl_suggest_approach "$_rl_lang" "$_rl_type" "$_rl_complexity" 2>/dev/null || true) if [[ -n "$_rl_suggestions" ]]; then info "RL suggests: $(echo "$_rl_suggestions" | head -1)" fi fi # ── Gather context bundle (if context engine available) ── local context_script="${SCRIPT_DIR}/sw-context.sh" if [[ -x "$context_script" ]]; then "$context_script" gather --goal "$GOAL" --stage plan 2>/dev/null || true fi # Gather rich architecture context (call-graph, dependencies) local arch_context="" if type gather_architecture_context &>/dev/null; then arch_context=$(gather_architecture_context "${PROJECT_ROOT:-.}" 2>/dev/null || true) fi # Build rich prompt with all available context local plan_prompt="You are an autonomous development agent. Analyze this codebase and create a detailed implementation plan. ## Goal ${GOAL} " # Add issue context if [[ -n "$ISSUE_BODY" ]]; then plan_prompt="${plan_prompt} ## Issue Description ${ISSUE_BODY} " fi # Inject architecture context (import graph, modules, test map) if [[ -n "$arch_context" ]]; then arch_context=$(prune_context_section "architecture" "$arch_context" 5000) plan_prompt="${plan_prompt} ## Architecture Context ${arch_context} " fi # Inject context bundle from context engine (if available) local _context_bundle="${ARTIFACTS_DIR}/context-bundle.md" if [[ -f "$_context_bundle" ]]; then local _cb_content _cb_content=$(cat "$_context_bundle" 2>/dev/null | head -100 || true) _cb_content=$(prune_context_section "context-bundle" "$_cb_content" 8000) if [[ -n "$_cb_content" ]]; then plan_prompt="${plan_prompt} ## Pipeline Context ${_cb_content} " fi fi # Inject intelligence memory context for similar past plans if type intelligence_search_memory >/dev/null 2>&1; then local plan_memory plan_memory=$(intelligence_search_memory "plan stage for ${TASK_TYPE:-feature}: ${GOAL:-}" "${HOME}/.shipwright/memory" 5 2>/dev/null) || true if [[ -n "$plan_memory" && "$plan_memory" != *'"results":[]'* && "$plan_memory" != *'"error"'* ]]; then local memory_summary memory_summary=$(echo "$plan_memory" | jq -r '.results[]? | "- \(.)"' 2>/dev/null | head -10 || true) memory_summary=$(prune_context_section "memory" "$memory_summary" 10000) if [[ -n "$memory_summary" ]]; then plan_prompt="${plan_prompt} ## Historical Context (from previous pipelines) Previous similar issues were planned as: ${memory_summary} " fi fi fi # Self-aware pipeline: inject hint when plan stage has been failing recently local plan_hint plan_hint=$(get_stage_self_awareness_hint "plan" 2>/dev/null || true) if [[ -n "$plan_hint" ]]; then plan_prompt="${plan_prompt} ## Self-Assessment (recent plan stage performance) ${plan_hint} " fi # Inject retry context from previous failed attempt if [[ -n "$_retry_hints" ]]; then plan_prompt="${plan_prompt} ## Previous Attempt Analysis (RETRY) This stage previously failed. Analysis of the failure: ${_retry_hints} Use this analysis to avoid repeating the same mistake. Address the root cause in your approach. " fi # Inject cross-pipeline discoveries (from other concurrent/similar pipelines) if [[ -x "$SCRIPT_DIR/sw-discovery.sh" ]]; then local plan_discoveries plan_discoveries=$("$SCRIPT_DIR/sw-discovery.sh" inject "*.md,*.json" 2>/dev/null | head -20 || true) plan_discoveries=$(prune_context_section "discoveries" "$plan_discoveries" 3000) if [[ -n "$plan_discoveries" ]]; then plan_prompt="${plan_prompt} ## Discoveries from Other Pipelines ${plan_discoveries} " fi fi # Inject architecture patterns from intelligence layer local repo_hash_plan repo_hash_plan=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown") local arch_file_plan="${HOME}/.shipwright/memory/${repo_hash_plan}/architecture.json" if [[ -f "$arch_file_plan" ]]; then local arch_patterns arch_patterns=$(jq -r ' "Language: \(.language // "unknown")", "Framework: \(.framework // "unknown")", "Patterns: \((.patterns // []) | join(", "))", "Rules: \((.rules // []) | join("; "))" ' "$arch_file_plan" 2>/dev/null || true) arch_patterns=$(prune_context_section "intelligence" "$arch_patterns" 5000) if [[ -n "$arch_patterns" ]]; then plan_prompt="${plan_prompt} ## Architecture Patterns ${arch_patterns} " fi fi # Inject skill prompts based on issue type classification # Prefer adaptive selection when available (combines body analysis + complexity weighting) if type skill_select_adaptive >/dev/null 2>&1; then local _skill_files _skill_prompts _skill_files=$(skill_select_adaptive "${INTELLIGENCE_ISSUE_TYPE:-backend}" "plan" "${ISSUE_BODY:-}" "${INTELLIGENCE_COMPLEXITY:-5}" 2>/dev/null || true) if [[ -n "$_skill_files" ]]; then # Load content from skill files _skill_prompts=$(while IFS= read -r _path; do [[ -z "$_path" ]] && continue [[ -f "$_path" ]] && cat "$_path" 2>/dev/null done <<< "$_skill_files") if [[ -n "$_skill_prompts" ]]; then _skill_prompts=$(prune_context_section "skills" "$_skill_prompts" 8000) plan_prompt="${plan_prompt} ## Skill Guidance (${INTELLIGENCE_ISSUE_TYPE:-backend} issue) ${_skill_prompts} " fi fi elif type skill_load_prompts >/dev/null 2>&1; then # Fallback to static selection local _skill_prompts _skill_prompts=$(skill_load_prompts "${INTELLIGENCE_ISSUE_TYPE:-backend}" "plan" 2>/dev/null || true) if [[ -n "$_skill_prompts" ]]; then _skill_prompts=$(prune_context_section "skills" "$_skill_prompts" 8000) plan_prompt="${plan_prompt} ## Skill Guidance (${INTELLIGENCE_ISSUE_TYPE:-backend} issue) ${_skill_prompts} " fi fi # Task-type-specific guidance case "${TASK_TYPE:-feature}" in bug) plan_prompt="${plan_prompt} ## Task Type: Bug Fix Focus on: reproducing the bug, identifying root cause, minimal targeted fix, regression tests. " ;; refactor) plan_prompt="${plan_prompt} ## Task Type: Refactor Focus on: preserving all existing behavior, incremental changes, comprehensive test coverage. " ;; security) plan_prompt="${plan_prompt} ## Task Type: Security Focus on: threat modeling, OWASP top 10, input validation, authentication/authorization. " ;; esac # Add project context local project_lang project_lang=$(detect_project_lang) plan_prompt="${plan_prompt} ## Project Context - Language: ${project_lang} - Test command: ${TEST_CMD:-not configured} - Task type: ${TASK_TYPE:-feature} ## Context Efficiency - Batch independent tool calls in parallel when possible - Read specific file sections (offset/limit) instead of entire large files - Use targeted grep searches — avoid scanning entire codebases into context - Delegate multi-file analysis to subagents when available ## Required Output Create a Markdown plan with these sections: ### Files to Modify List every file to create or modify with full paths. ### Implementation Steps Numbered steps in order of execution. Be specific about what code to write. ### Task Checklist A checkbox list of discrete tasks that can be tracked: - [ ] Task 1: Description - [ ] Task 2: Description (Include 5-15 tasks covering the full implementation) ### Testing Approach How to verify the implementation works. ### Definition of Done Checklist of completion criteria. " # Inject acceptance criteria as constraints if type format_acceptance_criteria_for_prompt >/dev/null 2>&1; then local criteria_section criteria_section=$(format_acceptance_criteria_for_prompt "$ARTIFACTS_DIR" 2>/dev/null || true) if [[ -n "$criteria_section" ]]; then plan_prompt="${plan_prompt} ## Acceptance Criteria (External Constraints) ${criteria_section} " fi fi # Inject mandatory failure mode analysis requirement if type inject_failure_mode_analysis >/dev/null 2>&1; then local quality_profile_path="${PROJECT_ROOT:-.}/.claude/quality-profile.json" plan_prompt=$(inject_failure_mode_analysis "$plan_prompt" "$quality_profile_path" 2>/dev/null || echo "$plan_prompt") fi # Inject skill prompts — prefer AI-powered plan, fallback to adaptive, then static local _skill_prompts="" if type skill_load_from_plan >/dev/null 2>&1; then _skill_prompts=$(skill_load_from_plan "plan" 2>/dev/null || true) elif type skill_select_adaptive >/dev/null 2>&1; then local _skill_files _skill_files=$(skill_select_adaptive "${INTELLIGENCE_ISSUE_TYPE:-backend}" "plan" "${ISSUE_BODY:-}" "${INTELLIGENCE_COMPLEXITY:-5}" 2>/dev/null || true) if [[ -n "$_skill_files" ]]; then _skill_prompts=$(while IFS= read -r _path; do [[ -z "$_path" || ! -f "$_path" ]] && continue cat "$_path" 2>/dev/null done <<< "$_skill_files") fi elif type skill_load_prompts >/dev/null 2>&1; then _skill_prompts=$(skill_load_prompts "${INTELLIGENCE_ISSUE_TYPE:-backend}" "plan" 2>/dev/null || true) fi if [[ -n "$_skill_prompts" ]]; then _skill_prompts=$(prune_context_section "skills" "$_skill_prompts" 8000) plan_prompt="${plan_prompt} ## Skill Guidance (${INTELLIGENCE_ISSUE_TYPE:-backend} issue, AI-selected) ${_skill_prompts} " fi # Guard total prompt size plan_prompt=$(guard_prompt_size "plan" "$plan_prompt") local plan_model plan_model=$(jq -r --arg id "plan" '(.stages[] | select(.id == $id) | .config.model) // .defaults.model // "opus"' "$PIPELINE_CONFIG" 2>/dev/null) || true [[ -n "$MODEL" ]] && plan_model="$MODEL" [[ -z "$plan_model" || "$plan_model" == "null" ]] && plan_model="opus" # Intelligence model routing (when no explicit CLI --model override) if [[ -z "$MODEL" && -n "${CLAUDE_MODEL:-}" ]]; then plan_model="$CLAUDE_MODEL" fi local _token_log="${ARTIFACTS_DIR}/.claude-tokens-plan.log" local _plan_flags _plan_flags="$(_pipeline_claude_flags "plan" "$plan_model")" # shellcheck disable=SC2086 claude --print $_plan_flags --max-turns "$(_smart_int "max_turns.pipeline_stage" 25)" --dangerously-skip-permissions \ "$plan_prompt" < /dev/null > "$plan_file" 2>"$_token_log" || true parse_claude_tokens "$_token_log" # Claude may write to disk via tools instead of stdout — rescue those files local _plan_rescue for _plan_rescue in "${PROJECT_ROOT}/PLAN.md" "${PROJECT_ROOT}/plan.md" \ "${PROJECT_ROOT}/implementation-plan.md"; do if [[ -s "$_plan_rescue" ]] && [[ $(wc -l < "$plan_file" 2>/dev/null | xargs) -lt 10 ]]; then info "Plan written to ${_plan_rescue} via tools — adopting as plan artifact" cat "$_plan_rescue" >> "$plan_file" rm -f "$_plan_rescue" break fi done if [[ ! -s "$plan_file" ]]; then error "Plan generation failed — empty output" return 1 fi # Validate plan content — detect API/CLI errors masquerading as plans local _plan_fatal="Invalid API key|invalid_api_key|authentication_error|API key expired" _plan_fatal="${_plan_fatal}|rate_limit_error|overloaded_error|Could not resolve host|ANTHROPIC_API_KEY" if grep -qiE "$_plan_fatal" "$plan_file" 2>/dev/null; then error "Plan stage produced API/CLI error instead of a plan: $(head -1 "$plan_file" | cut -c1-100)" return 1 fi local line_count line_count=$(wc -l < "$plan_file" | xargs) if [[ "$line_count" -lt 3 ]]; then error "Plan too short (${line_count} lines) — likely an error, not a real plan" return 1 fi info "Plan saved: ${DIM}$plan_file${RESET} (${line_count} lines)" # Extract task checklist for GitHub issue and task tracking local checklist checklist=$(sed -n '/### Task Checklist/,/^###/p' "$plan_file" 2>/dev/null | \ grep '^\s*- \[' | head -20) if [[ -z "$checklist" ]]; then # Fallback: extract any checkbox lines checklist=$(grep '^\s*- \[' "$plan_file" 2>/dev/null | head -20) fi # Write local task file for Claude Code build stage if [[ -n "$checklist" ]]; then cat > "$TASKS_FILE" < "$cc_tasks_file" < "$ARTIFACTS_DIR/dod.md" 2>/dev/null || true # ── Plan Validation Gate ── # Ask Claude to validate the plan before proceeding if command -v claude >/dev/null 2>&1 && [[ -s "$plan_file" ]]; then # Pre-validate: check failure mode analysis is present and adequate local failure_mode_status="" if type get_failure_mode_validation_status >/dev/null 2>&1; then failure_mode_status=$(get_failure_mode_validation_status "$plan_file" 2>/dev/null || echo "missing_section") if [[ "$failure_mode_status" != "valid" ]]; then warn "Plan missing adequate failure mode analysis (status: ${failure_mode_status})" # Log this as a validation rejection reason echo "missing_failure_analysis" > "$ARTIFACTS_DIR/.plan-failure-sig.txt" fi fi local validation_attempts=0 local max_validation_attempts=2 local plan_valid=false while [[ "$validation_attempts" -lt "$max_validation_attempts" ]]; do validation_attempts=$((validation_attempts + 1)) info "Validating plan (attempt ${validation_attempts}/${max_validation_attempts})..." # Build enriched validation prompt with learned context local validation_extra="" # Inject rejected plan history from memory if type intelligence_search_memory >/dev/null 2>&1; then local rejected_plans rejected_plans=$(intelligence_search_memory "rejected plan validation failures for: ${GOAL:-}" "${HOME}/.shipwright/memory" 3 2>/dev/null) || true if [[ -n "$rejected_plans" ]]; then validation_extra="${validation_extra} ## Previously Rejected Plans These issues were found in past plan validations for similar tasks: ${rejected_plans} " fi fi # Inject repo conventions contextually local claudemd="$PROJECT_ROOT/.claude/CLAUDE.md" if [[ -f "$claudemd" ]]; then local conventions_summary conventions_summary=$(head -100 "$claudemd" 2>/dev/null | grep -E '^##|^-|^\*' | head -15 || true) if [[ -n "$conventions_summary" ]]; then validation_extra="${validation_extra} ## Repo Conventions ${conventions_summary} " fi fi # Inject complexity estimate local complexity_hint="" if [[ -n "${INTELLIGENCE_COMPLEXITY:-}" && "${INTELLIGENCE_COMPLEXITY:-0}" -gt 0 ]]; then complexity_hint="This is estimated as complexity ${INTELLIGENCE_COMPLEXITY}/10. Plans for this complexity typically need ${INTELLIGENCE_COMPLEXITY} or more tasks." fi local validation_prompt="You are a plan validator. Review this implementation plan and determine if it is valid. ## Goal ${GOAL} ${complexity_hint:+ ## Complexity Estimate ${complexity_hint} } ## Plan $(cat "$plan_file") ${validation_extra} Evaluate: 1. Are all requirements from the goal addressed? 2. Is the plan decomposed into clear, achievable tasks? 3. Are the implementation steps specific enough to execute? Respond with EXACTLY one of these on the first line: VALID: true VALID: false Then explain your reasoning briefly." local validation_model="${plan_model:-opus}" local validation_result local _val_flags _val_flags="$(_pipeline_claude_flags "plan" "$validation_model")" # shellcheck disable=SC2086 validation_result=$(claude --print --output-format text $_val_flags -p "$validation_prompt" < /dev/null 2>"${ARTIFACTS_DIR}/.claude-tokens-plan-validate.log" || true) parse_claude_tokens "${ARTIFACTS_DIR}/.claude-tokens-plan-validate.log" # Save validation result echo "$validation_result" > "$ARTIFACTS_DIR/plan-validation.md" if echo "$validation_result" | head -5 | grep -qi "VALID: true"; then success "Plan validation passed" plan_valid=true break fi warn "Plan validation failed (attempt ${validation_attempts}/${max_validation_attempts})" # Analyze failure mode to decide how to recover local failure_mode="unknown" local validation_lower validation_lower=$(echo "$validation_result" | tr '[:upper:]' '[:lower:]') if echo "$validation_lower" | grep -qE 'failure mode|risk.*analysis|fail|risk'; then failure_mode="missing_failure_analysis" elif echo "$validation_lower" | grep -qE 'requirements? unclear|goal.*vague|ambiguous|underspecified'; then failure_mode="requirements_unclear" elif echo "$validation_lower" | grep -qE 'insufficient detail|not specific|too high.level|missing.*steps|lacks.*detail'; then failure_mode="insufficient_detail" elif echo "$validation_lower" | grep -qE 'scope too (large|broad)|too many|overly complex|break.*down'; then failure_mode="scope_too_large" fi emit_event "plan.validation_failure" \ "issue=${ISSUE_NUMBER:-0}" \ "attempt=$validation_attempts" \ "failure_mode=$failure_mode" # Track repeated failures — escalate if stuck in a loop if [[ -f "$ARTIFACTS_DIR/.plan-failure-sig.txt" ]]; then local prev_sig prev_sig=$(cat "$ARTIFACTS_DIR/.plan-failure-sig.txt" 2>/dev/null || true) if [[ "$failure_mode" == "$prev_sig" && "$failure_mode" != "unknown" ]]; then warn "Same validation failure mode repeated ($failure_mode) — escalating" emit_event "plan.validation_escalated" \ "issue=${ISSUE_NUMBER:-0}" \ "failure_mode=$failure_mode" break fi fi echo "$failure_mode" > "$ARTIFACTS_DIR/.plan-failure-sig.txt" if [[ "$validation_attempts" -lt "$max_validation_attempts" ]]; then info "Regenerating plan with validation feedback (mode: ${failure_mode})..." # Tailor regeneration prompt based on failure mode local failure_guidance="" case "$failure_mode" in missing_failure_analysis) failure_guidance="The validator found the failure mode analysis insufficient. The plan MUST include a Failure Mode Analysis section with at least 3 concrete failure modes specific to this codebase (not generic). For each major component, identify runtime failures, concurrency risks, scale risks, and rollback story. Reference specific architecture constraints and project technologies." ;; requirements_unclear) failure_guidance="The validator found the requirements unclear. Add more specific acceptance criteria, input/output examples, and concrete success metrics." ;; insufficient_detail) failure_guidance="The validator found the plan lacks detail. Break each task into smaller, more specific implementation steps with exact file paths and function names." ;; scope_too_large) failure_guidance="The validator found the scope too large. Focus on the minimal viable implementation and defer non-essential features to follow-up tasks." ;; esac local regen_prompt="${plan_prompt} IMPORTANT: A previous plan was rejected by validation. Issues found: $(echo "$validation_result" | tail -20) ${failure_guidance:+ GUIDANCE: ${failure_guidance}} Fix these issues in the new plan." local _regen_flags _regen_flags="$(_pipeline_claude_flags "plan" "$plan_model")" # shellcheck disable=SC2086 claude --print $_regen_flags --max-turns "$(_smart_int "max_turns.pipeline_stage" 25)" \ "$regen_prompt" < /dev/null > "$plan_file" 2>"$_token_log" || true parse_claude_tokens "$_token_log" line_count=$(wc -l < "$plan_file" | xargs) info "Regenerated plan: ${DIM}$plan_file${RESET} (${line_count} lines)" fi done if [[ "$plan_valid" != "true" ]]; then warn "Plan validation did not pass after ${max_validation_attempts} attempts — proceeding anyway" fi emit_event "plan.validated" \ "issue=${ISSUE_NUMBER:-0}" \ "valid=${plan_valid}" \ "attempts=${validation_attempts}" fi log_stage "plan" "Generated plan.md (${line_count} lines, $(echo "$checklist" | wc -l | xargs) tasks)" } stage_design() { CURRENT_STAGE_ID="design" # Consume retry context if this is a retry attempt local _retry_ctx="${ARTIFACTS_DIR}/.retry-context-design.md" local _design_retry_hints="" if [[ -s "$_retry_ctx" ]]; then _design_retry_hints=$(cat "$_retry_ctx" 2>/dev/null || true) rm -f "$_retry_ctx" fi local plan_file="$ARTIFACTS_DIR/plan.md" local design_file="$ARTIFACTS_DIR/design.md" if [[ ! -s "$plan_file" ]]; then warn "No plan found — skipping design stage" return 0 fi if ! command -v claude >/dev/null 2>&1; then error "Claude CLI not found — cannot generate design" return 1 fi info "Generating Architecture Decision Record..." # Gather rich architecture context (call-graph, dependencies) local arch_struct_context="" if type gather_architecture_context &>/dev/null; then arch_struct_context=$(gather_architecture_context "${PROJECT_ROOT:-.}" 2>/dev/null || true) fi arch_struct_context=$(prune_context_section "architecture" "$arch_struct_context" 5000) # Memory integration — inject context if memory system available local memory_context="" if type intelligence_search_memory >/dev/null 2>&1; then local mem_dir="${HOME}/.shipwright/memory" memory_context=$(intelligence_search_memory "design stage architecture patterns for: ${GOAL:-}" "$mem_dir" 5 2>/dev/null) || true fi if [[ -z "$memory_context" ]] && [[ -x "$SCRIPT_DIR/sw-memory.sh" ]]; then memory_context=$(bash "$SCRIPT_DIR/sw-memory.sh" inject "design" 2>/dev/null) || true fi memory_context=$(prune_context_section "memory" "$memory_context" 10000) # Inject cross-pipeline discoveries for design stage local design_discoveries="" if [[ -x "$SCRIPT_DIR/sw-discovery.sh" ]]; then design_discoveries=$("$SCRIPT_DIR/sw-discovery.sh" inject "*.md,*.ts,*.tsx,*.js" 2>/dev/null | head -20 || true) fi design_discoveries=$(prune_context_section "discoveries" "$design_discoveries" 3000) # Inject architecture model patterns if available local arch_context="" local repo_hash repo_hash=$(echo -n "$PROJECT_ROOT" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown") local arch_model_file="${HOME}/.shipwright/memory/${repo_hash}/architecture.json" if [[ -f "$arch_model_file" ]]; then local arch_patterns arch_patterns=$(jq -r ' [.patterns // [] | .[] | "- \(.name // "unnamed"): \(.description // "no description")"] | join("\n") ' "$arch_model_file" 2>/dev/null) || true local arch_layers arch_layers=$(jq -r ' [.layers // [] | .[] | "- \(.name // "unnamed"): \(.path // "")"] | join("\n") ' "$arch_model_file" 2>/dev/null) || true if [[ -n "$arch_patterns" || -n "$arch_layers" ]]; then arch_context="Previous designs in this repo follow these patterns: ${arch_patterns:+Patterns: ${arch_patterns} }${arch_layers:+Layers: ${arch_layers}}" fi fi arch_context=$(prune_context_section "intelligence" "$arch_context" 5000) # Inject rejected design approaches and anti-patterns from memory local design_antipatterns="" if type intelligence_search_memory >/dev/null 2>&1; then local rejected_designs rejected_designs=$(intelligence_search_memory "rejected design approaches anti-patterns for: ${GOAL:-}" "${HOME}/.shipwright/memory" 3 2>/dev/null) || true if [[ -n "$rejected_designs" ]]; then rejected_designs=$(prune_context_section "antipatterns" "$rejected_designs" 5000) design_antipatterns=" ## Rejected Approaches (from past reviews) These design approaches were rejected in past reviews. Avoid repeating them: ${rejected_designs} " fi fi # Build design prompt with plan + project context local project_lang project_lang=$(detect_project_lang) local design_prompt="You are a senior software architect. Review the implementation plan below and produce an Architecture Decision Record (ADR). ## Goal ${GOAL} ## Implementation Plan $(cat "$plan_file") ## Project Context - Language: ${project_lang} - Test command: ${TEST_CMD:-not configured} - Task type: ${TASK_TYPE:-feature} ${arch_struct_context:+ ## Architecture Context (import graph, modules, test map) ${arch_struct_context} }${memory_context:+ ## Historical Context (from memory) ${memory_context} }${arch_context:+ ## Architecture Model (from previous designs) ${arch_context} }${design_antipatterns}${design_discoveries:+ ## Discoveries from Other Pipelines ${design_discoveries} } ## Required Output — Architecture Decision Record Produce this EXACT format: # Design: ${GOAL} ## Context [What problem we're solving, constraints from the codebase] ## Decision [The chosen approach — be specific about patterns, data flow, error handling] ## Alternatives Considered 1. [Alternative A] — Pros: ... / Cons: ... 2. [Alternative B] — Pros: ... / Cons: ... ## Implementation Plan - Files to create: [list with full paths] - Files to modify: [list with full paths] - Dependencies: [new deps if any] - Risk areas: [fragile code, performance concerns] ## Validation Criteria - [ ] [How we'll know the design is correct — testable criteria] - [ ] [Additional validation items] Be concrete and specific. Reference actual file paths in the codebase. Consider edge cases and failure modes." # Inject skill prompts for design stage local _skill_prompts="" if type skill_load_from_plan >/dev/null 2>&1; then _skill_prompts=$(skill_load_from_plan "design" 2>/dev/null || true) elif type skill_select_adaptive >/dev/null 2>&1; then local _skill_files _skill_files=$(skill_select_adaptive "${INTELLIGENCE_ISSUE_TYPE:-backend}" "design" "${ISSUE_BODY:-}" "${INTELLIGENCE_COMPLEXITY:-5}" 2>/dev/null || true) if [[ -n "$_skill_files" ]]; then _skill_prompts=$(while IFS= read -r _path; do [[ -z "$_path" || ! -f "$_path" ]] && continue cat "$_path" 2>/dev/null done <<< "$_skill_files") fi elif type skill_load_prompts >/dev/null 2>&1; then _skill_prompts=$(skill_load_prompts "${INTELLIGENCE_ISSUE_TYPE:-backend}" "design" 2>/dev/null || true) fi if [[ -n "$_skill_prompts" ]]; then _skill_prompts=$(prune_context_section "skills" "$_skill_prompts" 8000) design_prompt="${design_prompt} ## Skill Guidance (${INTELLIGENCE_ISSUE_TYPE:-backend} issue, AI-selected) ${_skill_prompts} " fi # Guard total prompt size design_prompt=$(guard_prompt_size "design" "$design_prompt") local design_model design_model=$(jq -r --arg id "design" '(.stages[] | select(.id == $id) | .config.model) // .defaults.model // "opus"' "$PIPELINE_CONFIG" 2>/dev/null) || true [[ -n "$MODEL" ]] && design_model="$MODEL" [[ -z "$design_model" || "$design_model" == "null" ]] && design_model="opus" # Intelligence model routing (when no explicit CLI --model override) if [[ -z "$MODEL" && -n "${CLAUDE_MODEL:-}" ]]; then design_model="$CLAUDE_MODEL" fi local _token_log="${ARTIFACTS_DIR}/.claude-tokens-design.log" local _design_flags _design_flags="$(_pipeline_claude_flags "design" "$design_model")" # shellcheck disable=SC2086 claude --print $_design_flags --max-turns "$(_smart_int "max_turns.pipeline_stage" 25)" --dangerously-skip-permissions \ "$design_prompt" < /dev/null > "$design_file" 2>"$_token_log" || true parse_claude_tokens "$_token_log" # Claude may write to disk via tools instead of stdout — rescue those files local _design_rescue for _design_rescue in "${PROJECT_ROOT}/design-adr.md" "${PROJECT_ROOT}/design.md" \ "${PROJECT_ROOT}/ADR.md" "${PROJECT_ROOT}/DESIGN.md"; do if [[ -s "$_design_rescue" ]] && [[ $(wc -l < "$design_file" 2>/dev/null | xargs) -lt 10 ]]; then info "Design written to ${_design_rescue} via tools — adopting as design artifact" cat "$_design_rescue" >> "$design_file" rm -f "$_design_rescue" break fi done if [[ ! -s "$design_file" ]]; then error "Design generation failed — empty output" return 1 fi # Validate design content — detect API/CLI errors masquerading as designs local _design_fatal="Invalid API key|invalid_api_key|authentication_error|API key expired" _design_fatal="${_design_fatal}|rate_limit_error|overloaded_error|Could not resolve host|ANTHROPIC_API_KEY" if grep -qiE "$_design_fatal" "$design_file" 2>/dev/null; then error "Design stage produced API/CLI error instead of a design: $(head -1 "$design_file" | cut -c1-100)" return 1 fi local line_count line_count=$(wc -l < "$design_file" | xargs) if [[ "$line_count" -lt 3 ]]; then error "Design too short (${line_count} lines) — likely an error, not a real design" return 1 fi info "Design saved: ${DIM}$design_file${RESET} (${line_count} lines)" # Extract file lists for build stage awareness local files_to_create files_to_modify files_to_create=$(sed -n '/Files to create/,/^-\|^#\|^$/p' "$design_file" 2>/dev/null | grep -E '^\s*-' | head -20 || true) files_to_modify=$(sed -n '/Files to modify/,/^-\|^#\|^$/p' "$design_file" 2>/dev/null | grep -E '^\s*-' | head -20 || true) if [[ -n "$files_to_create" || -n "$files_to_modify" ]]; then info "Design scope: ${DIM}$(echo "$files_to_create $files_to_modify" | grep -c '^\s*-' || true) file(s)${RESET}" fi # Post design to GitHub issue if [[ -n "$ISSUE_NUMBER" ]]; then local design_summary design_summary=$(head -60 "$design_file") gh_comment_issue "$ISSUE_NUMBER" "## 📐 Architecture Decision Record
Click to expand ADR (${line_count} lines) ${design_summary}
--- _Generated by \`shipwright pipeline\` design stage at $(now_iso)_" fi # Push design to wiki gh_wiki_page "Pipeline-Design-${ISSUE_NUMBER:-inline}" "$(<"$design_file")" log_stage "design" "Generated design.md (${line_count} lines)" } # ─── TDD: Generate tests before implementation ─────────────────────────────────