@jonit-dev/night-watch-cli 1.7.48 → 1.7.50

package/dist/scripts/night-watch-audit-cron.sh

@@ -106,42 +106,65 @@ fi
 # Ensure the logs dir exists inside the worktree so the provider can write the report
 mkdir -p "${AUDIT_WORKTREE_DIR}/logs"
 
+AUDIT_MAX_RETRIES="${NW_AUDIT_MAX_RETRIES:-3}"
+AUDIT_RETRY_DELAY="${NW_AUDIT_RETRY_DELAY:-120}"
+
 log "START: Running code audit for ${PROJECT_NAME} (provider: ${PROVIDER_CMD})"
 
 EXIT_CODE=0
 
-case "${PROVIDER_CMD}" in
-  claude)
-    if (
-      cd "${AUDIT_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
-        claude -p "${AUDIT_PROMPT}" \
-          --dangerously-skip-permissions \
-          >> "${LOG_FILE}" 2>&1
-    ); then
-      EXIT_CODE=0
-    else
-      EXIT_CODE=$?
-    fi
-    ;;
-  codex)
-    if (
-      cd "${AUDIT_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
-        codex --quiet \
-          --yolo \
-          --prompt "${AUDIT_PROMPT}" \
-          >> "${LOG_FILE}" 2>&1
-    ); then
-      EXIT_CODE=0
-    else
-      EXIT_CODE=$?
-    fi
-    ;;
-  *)
-    log "ERROR: Unknown provider: ${PROVIDER_CMD}"
-    emit_result "failure" "reason=unknown_provider"
-    exit 1
-    ;;
-esac
+for AUDIT_ATTEMPT in $(seq 1 "${AUDIT_MAX_RETRIES}"); do
+  LOG_LINE_BEFORE=$(wc -l < "${LOG_FILE}" 2>/dev/null || echo 0)
+  log "AUDIT: Attempt ${AUDIT_ATTEMPT}/${AUDIT_MAX_RETRIES}"
+
+  case "${PROVIDER_CMD}" in
+    claude)
+      if (
+        cd "${AUDIT_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
+          claude -p "${AUDIT_PROMPT}" \
+            --dangerously-skip-permissions \
+            >> "${LOG_FILE}" 2>&1
+      ); then
+        EXIT_CODE=0
+      else
+        EXIT_CODE=$?
+      fi
+      ;;
+    codex)
+      if (
+        cd "${AUDIT_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
+          codex --quiet \
+            --yolo \
+            --prompt "${AUDIT_PROMPT}" \
+            >> "${LOG_FILE}" 2>&1
+      ); then
+        EXIT_CODE=0
+      else
+        EXIT_CODE=$?
+      fi
+      ;;
+    *)
+      log "ERROR: Unknown provider: ${PROVIDER_CMD}"
+      emit_result "failure" "reason=unknown_provider"
+      exit 1
+      ;;
+  esac
+
+  # Success or timeout — don't retry
+  if [ "${EXIT_CODE}" -eq 0 ] || [ "${EXIT_CODE}" -eq 124 ]; then
+    break
+  fi
+
+  # Rate-limit retry with backoff
+  if check_rate_limited "${LOG_FILE}" "${LOG_LINE_BEFORE}" && [ "${AUDIT_ATTEMPT}" -lt "${AUDIT_MAX_RETRIES}" ]; then
+    log "RATE-LIMITED: 429 detected (attempt ${AUDIT_ATTEMPT}/${AUDIT_MAX_RETRIES}), retrying in ${AUDIT_RETRY_DELAY}s..."
+    sleep "${AUDIT_RETRY_DELAY}"
+    continue
+  fi
+
+  # Non-retryable failure
+  break
+done
 
 # Copy report back to project dir (if it was written in the worktree)
 WORKTREE_REPORT="${AUDIT_WORKTREE_DIR}/logs/audit-report.md"

package/dist/scripts/night-watch-cron.sh

@@ -184,6 +184,95 @@ count_prs_for_branch() {
   echo "${count:-0}"
 }
 
+checkpoint_timeout_progress() {
+  local worktree_dir="${1:?worktree_dir required}"
+  local branch_name="${2:?branch_name required}"
+  local prd_file="${3:?prd_file required}"
+
+  if [ ! -d "${worktree_dir}" ]; then
+    return 0
+  fi
+
+  if ! git -C "${worktree_dir}" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    return 0
+  fi
+
+  if [ -z "$(git -C "${worktree_dir}" status --porcelain 2>/dev/null)" ]; then
+    log "TIMEOUT: No local changes to checkpoint for ${prd_file}"
+    return 0
+  fi
+
+  log "TIMEOUT: Checkpointing local progress for ${prd_file} on ${branch_name}"
+  if git -C "${worktree_dir}" add -A >/dev/null 2>&1; then
+    if ! git -C "${worktree_dir}" diff --cached --quiet >/dev/null 2>&1; then
+      git -C "${worktree_dir}" commit --no-verify \
+        -m "chore: checkpoint timed-out progress for ${prd_file}" \
+        >> "${LOG_FILE}" 2>&1 || true
+    fi
+  fi
+}
+
+extract_timeout_phase_titles() {
+  local issue_body="${1:-}"
+  if [ -z "${issue_body}" ]; then
+    return 0
+  fi
+
+  printf '%s\n' "${issue_body}" \
+    | tr -d '\r' \
+    | awk '
+        BEGIN { count = 0 }
+        /^[[:space:]]*#{2,4}[[:space:]]*Phase[[:space:]]+[0-9]+[[:space:]]*:/ {
+          line = $0
+          sub(/^[[:space:]]*#{2,4}[[:space:]]*/, "", line)
+          gsub(/[[:space:]]+$/, "", line)
+          if (count < 3) {
+            count++
+            print line
+          }
+        }
+      '
+}
+
+build_timeout_followup_comment() {
+  local max_runtime="${1:?max_runtime required}"
+  local prd_label="${2:?prd_label required}"
+  local branch_name="${3:?branch_name required}"
+  local issue_body="${4:-}"
+  local phase_titles=""
+  local comment=""
+
+  phase_titles=$(extract_timeout_phase_titles "${issue_body}" || true)
+
+  comment="Timeout follow-up:
+
+Execution hit the ${max_runtime}s runtime limit while processing ${prd_label}.
+Progress was checkpointed on branch ${branch_name}, so the next run will resume from the latest checkpoint.
+
+Suggested slices for the next runs:"
+
+  if [ -n "${phase_titles}" ]; then
+    local idx=1
+    while IFS= read -r phase_title; do
+      [ -z "${phase_title}" ] && continue
+      comment="${comment}
+${idx}. ${phase_title}"
+      idx=$((idx + 1))
+    done <<< "${phase_titles}"
+  else
+    comment="${comment}
+1. Phase 1: Setup and interfaces
+2. Phase 2: Core implementation and tests
+3. Phase 3: Integration and verification"
+  fi
+
+  comment="${comment}
+
+Recommendation: avoid huge PRDs. Slice large work into smaller PRDs/phases so each run can finish within the runtime window."
+
+  printf '%s' "${comment}"
+}
+
 finalize_prd_done() {
   local reason="${1:?reason required}"
 
@@ -215,6 +304,16 @@ Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>" || true
 
 log "START: Processing ${ELIGIBLE_PRD} on branch ${BRANCH_NAME} (worktree: ${WORKTREE_DIR})"
 
+EXECUTOR_PROMPT_PATH=$(resolve_instruction_path "${PROJECT_DIR}" "prd-executor.md" || true)
+if [ -z "${EXECUTOR_PROMPT_PATH}" ]; then
+  log "FAIL: Missing PRD executor instructions. Checked instructions/, .claude/commands/, and bundled templates/"
+  restore_issue_to_ready "Failed to locate PRD executor instructions. Checked instructions/, .claude/commands/, and bundled templates/."
+  night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
+  emit_result "failure" "reason=missing_executor_prompt"
+  exit 1
+fi
+EXECUTOR_PROMPT_REF=$(instruction_ref_for_prompt "${PROJECT_DIR}" "${EXECUTOR_PROMPT_PATH}")
+
 if [ -n "${ISSUE_NUMBER}" ]; then
   PROMPT="Implement the following PRD (GitHub issue #${ISSUE_NUMBER}: ${ISSUE_TITLE_RAW}):
 
@@ -228,7 +327,7 @@ ${ISSUE_BODY}
 - Install dependencies if needed and implement in the current worktree only
 
 ## Implementation — PRD Executor Workflow
-Read .claude/skills/prd-executor/SKILL.md (preferred) or .claude/commands/prd-executor.md (fallback), and follow the FULL execution pipeline:
+Read ${EXECUTOR_PROMPT_REF} and follow the FULL execution pipeline:
 1. Parse the PRD into phases and extract dependencies
 2. Build a dependency graph to identify parallelism
 3. Create a task list with one task per phase
@@ -256,7 +355,7 @@ else
 - Install dependencies if needed and implement in the current worktree only
 
 ## Implementation — PRD Executor Workflow
-Read .claude/skills/prd-executor/SKILL.md (preferred) or .claude/commands/prd-executor.md (fallback), and follow the FULL execution pipeline:
+Read ${EXECUTOR_PROMPT_REF} and follow the FULL execution pipeline:
 1. Parse the PRD into phases and extract dependencies
 2. Build a dependency graph to identify parallelism
 3. Create a task list with one task per phase
@@ -472,10 +571,17 @@ if [ ${EXIT_CODE} -eq 0 ]; then
   fi
 elif [ ${EXIT_CODE} -eq 124 ]; then
   log "TIMEOUT: Night watch killed after ${MAX_RUNTIME}s while processing ${ELIGIBLE_PRD}"
+  checkpoint_timeout_progress "${WORKTREE_DIR}" "${BRANCH_NAME}" "${ELIGIBLE_PRD}"
   if [ -n "${ISSUE_NUMBER}" ]; then
     "${NW_CLI}" board move-issue "${ISSUE_NUMBER}" --column "Ready" 2>>"${LOG_FILE}" || true
     "${NW_CLI}" board comment "${ISSUE_NUMBER}" \
       --body "Execution timed out after ${MAX_RUNTIME}s. Moved back to Ready for retry." 2>>"${LOG_FILE}" || true
+    TIMEOUT_FOLLOWUP_COMMENT=$(build_timeout_followup_comment \
+      "${MAX_RUNTIME}" \
+      "${ELIGIBLE_PRD}" \
+      "${BRANCH_NAME}" \
+      "${ISSUE_BODY}")
+    "${NW_CLI}" board comment "${ISSUE_NUMBER}" --body "${TIMEOUT_FOLLOWUP_COMMENT}" 2>>"${LOG_FILE}" || true
   fi
   night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" timeout --exit-code 124 2>/dev/null || true
   emit_result "timeout" "prd=${ELIGIBLE_PRD}|branch=${BRANCH_NAME}"

package/dist/scripts/night-watch-helpers.sh

@@ -51,6 +51,42 @@ resolve_night_watch_cli() {
   return 1
 }
 
+resolve_instruction_path() {
+  local project_dir="${1:?project_dir required}"
+  local instruction_file="${2:?instruction_file required}"
+  local script_dir=""
+  local candidate=""
+
+  if [ -n "${SCRIPT_DIR:-}" ]; then
+    script_dir="${SCRIPT_DIR}"
+  else
+    script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  fi
+
+  for candidate in \
+    "${project_dir}/instructions/${instruction_file}" \
+    "${project_dir}/.claude/commands/${instruction_file}" \
+    "${script_dir}/../templates/${instruction_file}"; do
+    if [ -f "${candidate}" ]; then
+      printf "%s" "${candidate}"
+      return 0
+    fi
+  done
+
+  return 1
+}
+
+instruction_ref_for_prompt() {
+  local root_dir="${1:?root_dir required}"
+  local instruction_path="${2:?instruction_path required}"
+
+  if [[ "${instruction_path}" == "${root_dir}/"* ]]; then
+    printf "%s" "${instruction_path#${root_dir}/}"
+  else
+    printf "%s" "${instruction_path}"
+  fi
+}
+
 night_watch_history() {
   local cli_bin
   cli_bin=$(resolve_night_watch_cli) || return 127

package/dist/scripts/night-watch-pr-reviewer-cron.sh

@@ -143,6 +143,135 @@ get_pr_score() {
     | grep -oP '\d+(?=/100)' || echo ""
 }
 
+# Count failed CI checks for a PR.
+# Uses JSON fields when available (more reliable across check name/status formats),
+# then falls back to text parsing for older/mocked gh outputs.
+get_pr_failed_ci_checks() {
+  local pr_number="${1:?PR number required}"
+  local failed_count=""
+
+  failed_count="$(
+    gh pr checks "${pr_number}" --json bucket,state,conclusion --jq '
+      [ .[]
+        | (.bucket // "" | ascii_downcase) as $bucket
+        | (.state // "" | ascii_downcase) as $state
+        | (.conclusion // "" | ascii_downcase) as $conclusion
+        | select(
+            $bucket == "fail" or
+            $bucket == "cancel" or
+            $state == "failure" or
+            $state == "error" or
+            $state == "cancelled" or
+            $conclusion == "failure" or
+            $conclusion == "error" or
+            $conclusion == "cancelled" or
+            $conclusion == "timed_out" or
+            $conclusion == "action_required" or
+            $conclusion == "startup_failure" or
+            $conclusion == "stale"
+          )
+      ] | length
+    ' 2>/dev/null || true
+  )"
+
+  if [[ "${failed_count}" =~ ^[0-9]+$ ]]; then
+    echo "${failed_count}"
+    return 0
+  fi
+
+  failed_count=$(
+    gh pr checks "${pr_number}" 2>/dev/null \
+      | grep -Eci 'fail|error|cancel|timed[_ -]?out|action_required|startup_failure|stale' || true
+  )
+
+  if [[ "${failed_count}" =~ ^[0-9]+$ ]]; then
+    echo "${failed_count}"
+  else
+    echo "0"
+  fi
+}
+
+# Return a semicolon-separated summary of failing CI checks for a PR.
+# Format: "<check name> [state=<state>, conclusion=<conclusion>]"
+get_pr_failed_ci_summary() {
+  local pr_number="${1:?PR number required}"
+  local failed_summary=""
+
+  failed_summary="$(
+    gh pr checks "${pr_number}" --json name,bucket,state,conclusion --jq '
+      [ .[]
+        | (.bucket // "" | ascii_downcase) as $bucket
+        | (.state // "" | ascii_downcase) as $state
+        | (.conclusion // "" | ascii_downcase) as $conclusion
+        | select(
+            $bucket == "fail" or
+            $bucket == "cancel" or
+            $state == "failure" or
+            $state == "error" or
+            $state == "cancelled" or
+            $conclusion == "failure" or
+            $conclusion == "error" or
+            $conclusion == "cancelled" or
+            $conclusion == "timed_out" or
+            $conclusion == "action_required" or
+            $conclusion == "startup_failure" or
+            $conclusion == "stale"
+          )
+        | "\(.name // "unknown") [state=\(.state // "unknown"), conclusion=\(.conclusion // "unknown")]"
+      ] | join("; ")
+    ' 2>/dev/null || true
+  )"
+
+  if [ -n "${failed_summary}" ]; then
+    echo "${failed_summary}"
+    return 0
+  fi
+
+  # Fallback for older/mocked outputs where JSON fields aren't available.
+  failed_summary=$(
+    gh pr checks "${pr_number}" 2>/dev/null \
+      | grep -Ei 'fail|error|cancel|timed[_ -]?out|action_required|startup_failure|stale' \
+      | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]][[:space:]]*/ /g' \
+      | paste -sd '; ' - || true
+  )
+
+  echo "${failed_summary}"
+}
+
+# Clean up reviewer-managed worktrees.
+# - Always removes the caller's runner worktree when runner_scope is provided.
+# - Only non-worker/controller processes perform broad cleanup to avoid
+#   parallel workers deleting each other's active worktrees.
+cleanup_reviewer_worktrees() {
+  local runner_scope="${1:-}"
+
+  if [ -n "${runner_scope}" ]; then
+    cleanup_worktrees "${PROJECT_DIR}" "${runner_scope}"
+  fi
+
+  if [ "${WORKER_MODE}" = "1" ]; then
+    return 0
+  fi
+
+  # Remove per-PR reviewer worktrees created by prompts from older runs.
+  cleanup_worktrees "${PROJECT_DIR}" "${PROJECT_NAME}-nw-review-"
+
+  # Remove legacy reviewer worktree naming used in some older prompt variants.
+  local escaped_project_name
+  escaped_project_name=$(printf '%s\n' "${PROJECT_NAME}" | sed 's/[][(){}.^$*+?|\\/]/\\&/g')
+  git -C "${PROJECT_DIR}" worktree list --porcelain 2>/dev/null \
+    | grep '^worktree ' \
+    | awk '{print $2}' \
+    | while read -r wt; do
+        local wt_basename
+        wt_basename=$(basename "${wt}")
+        if printf '%s\n' "${wt_basename}" | grep -Eq "^${escaped_project_name}-pr-?[0-9]+$"; then
+          log "CLEANUP: Removing legacy reviewer worktree ${wt}"
+          git -C "${PROJECT_DIR}" worktree remove --force "${wt}" 2>/dev/null || true
+        fi
+      done || true
+}
+
 # Validate provider
 if ! validate_provider "${PROVIDER_CMD}"; then
   echo "ERROR: Unknown provider: ${PROVIDER_CMD}" >&2
@@ -221,9 +350,14 @@ while IFS=$'\t' read -r pr_number pr_branch; do
     continue
   fi
 
-  FAILED_CHECKS=$(gh pr checks "${pr_number}" 2>/dev/null | grep -ci 'fail' || true)
+  FAILED_CHECKS=$(get_pr_failed_ci_checks "${pr_number}")
   if [ "${FAILED_CHECKS}" -gt 0 ]; then
-    log "INFO: PR #${pr_number} (${pr_branch}) has ${FAILED_CHECKS} failed CI check(s)"
+    FAILED_SUMMARY=$(get_pr_failed_ci_summary "${pr_number}")
+    if [ -n "${FAILED_SUMMARY}" ]; then
+      log "INFO: PR #${pr_number} (${pr_branch}) has ${FAILED_CHECKS} failed CI check(s): ${FAILED_SUMMARY}"
+    else
+      log "INFO: PR #${pr_number} (${pr_branch}) has ${FAILED_CHECKS} failed CI check(s)"
+    fi
     NEEDS_WORK=1
     PRS_NEEDING_WORK="${PRS_NEEDING_WORK} #${pr_number}"
     continue
@@ -325,6 +459,10 @@ fi
 
 log "START: Found PR(s) needing work:${PRS_NEEDING_WORK}"
 
+# Remove stale reviewer worktrees from previous interrupted runs.
+# Worker processes skip broad cleanup to avoid parallel interference.
+cleanup_reviewer_worktrees
+
 # Convert "#12 #34" into ["12", "34"] for worker fan-out.
 PR_NUMBER_ARRAY=()
 for pr_token in ${PRS_NEEDING_WORK}; do
@@ -355,7 +493,14 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
   declare -a WORKER_PRS=()
   declare -a WORKER_OUTPUTS=()
 
+  WORKER_IDX=0
+  WORKER_STAGGER_DELAY="${NW_REVIEWER_WORKER_STAGGER:-60}"
   for pr_number in "${PR_NUMBER_ARRAY[@]}"; do
+    if [ "${WORKER_IDX}" -gt 0 ]; then
+      log "PARALLEL: Staggering worker launch by ${WORKER_STAGGER_DELAY}s (worker $((WORKER_IDX + 1))/${#PR_NUMBER_ARRAY[@]})"
+      sleep "${WORKER_STAGGER_DELAY}"
+    fi
+
     worker_output=$(mktemp "/tmp/night-watch-pr-reviewer-${PROJECT_RUNTIME_KEY}-pr-${pr_number}.XXXXXX")
     WORKER_OUTPUTS+=("${worker_output}")
     WORKER_PRS+=("${pr_number}")
@@ -370,6 +515,7 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
     worker_pid=$!
     WORKER_PIDS+=("${worker_pid}")
     log "PARALLEL: Worker PID ${worker_pid} started for PR #${pr_number}"
+    WORKER_IDX=$((WORKER_IDX + 1))
   done
 
   EXIT_CODE=0
@@ -439,6 +585,10 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
     fi
   done
 
+  # Parent/controller process cleans up any per-PR reviewer worktrees that
+  # worker runs may have left behind.
+  cleanup_reviewer_worktrees
+
   emit_final_status "${EXIT_CODE}" "${PRS_NEEDING_WORK_CSV}" "${AUTO_MERGED_PRS}" "${AUTO_MERGE_FAILED_PRS}" "${MAX_WORKER_ATTEMPTS}" "${MAX_WORKER_FINAL_SCORE}"
   exit 0
 fi
@@ -449,7 +599,7 @@ if [ -n "${TARGET_PR}" ]; then
 fi
 REVIEW_WORKTREE_DIR="$(dirname "${PROJECT_DIR}")/${REVIEW_WORKTREE_BASENAME}"
 
-cleanup_worktrees "${PROJECT_DIR}" "${REVIEW_WORKTREE_BASENAME}"
+cleanup_reviewer_worktrees "${REVIEW_WORKTREE_BASENAME}"
 
 # Dry-run mode: print diagnostics and exit
 if [ "${NW_DRY_RUN:-0}" = "1" ]; then
@@ -479,12 +629,38 @@ if ! prepare_detached_worktree "${PROJECT_DIR}" "${REVIEW_WORKTREE_DIR}" "${DEFA
   exit 1
 fi
 
+REVIEWER_PROMPT_PATH=$(resolve_instruction_path "${REVIEW_WORKTREE_DIR}" "night-watch-pr-reviewer.md" || true)
+if [ -z "${REVIEWER_PROMPT_PATH}" ]; then
+  log "FAIL: Missing reviewer prompt file. Checked instructions/, .claude/commands/, and bundled templates/"
+  emit_result "failure" "reason=missing_reviewer_prompt"
+  exit 1
+fi
+REVIEWER_PROMPT_BASE=$(cat "${REVIEWER_PROMPT_PATH}")
+REVIEWER_PROMPT_REF=$(instruction_ref_for_prompt "${REVIEW_WORKTREE_DIR}" "${REVIEWER_PROMPT_PATH}")
+log "INFO: Using reviewer prompt from ${REVIEWER_PROMPT_REF}"
+
 EXIT_CODE=0
 ATTEMPTS_MADE=1
 FINAL_SCORE=""
 TARGET_SCOPE_PROMPT=""
 if [ -n "${TARGET_PR}" ]; then
   TARGET_SCOPE_PROMPT=$'\n\n## Target Scope\n- Only process PR #'"${TARGET_PR}"$'.\n- Ignore all other PRs.\n- If this PR no longer needs work, stop immediately.\n'
+
+  TARGET_MERGE_STATE=$(gh pr view "${TARGET_PR}" --json mergeStateStatus --jq '.mergeStateStatus' 2>/dev/null || echo "UNKNOWN")
+  TARGET_FAILED_CHECKS=$(get_pr_failed_ci_summary "${TARGET_PR}")
+  TARGET_SCORE=$(get_pr_score "${TARGET_PR}")
+
+  TARGET_SCOPE_PROMPT+=$'\n## Preflight Data (from CLI)\n- mergeStateStatus: '"${TARGET_MERGE_STATE}"$'\n'
+  if [ -n "${TARGET_FAILED_CHECKS}" ]; then
+    TARGET_SCOPE_PROMPT+=$'- failing checks: '"${TARGET_FAILED_CHECKS}"$'\n'
+  else
+    TARGET_SCOPE_PROMPT+=$'- failing checks: none detected\n'
+  fi
+  if [ -n "${TARGET_SCORE}" ]; then
+    TARGET_SCOPE_PROMPT+=$'- latest review score: '"${TARGET_SCORE}"$'/100\n'
+  else
+    TARGET_SCOPE_PROMPT+=$'- latest review score: not found\n'
+  fi
 fi
 
 # ── Retry Loop for Targeted PR Review ──────────────────────────────────────────
@@ -518,13 +694,14 @@ for ATTEMPT in $(seq 1 "${TOTAL_ATTEMPTS}"); do
   fi
 
   log "RETRY: Starting attempt ${ATTEMPT}/${TOTAL_ATTEMPTS} (timeout: ${ATTEMPT_TIMEOUT}s)"
+  LOG_LINE_BEFORE=$(wc -l < "${LOG_FILE}" 2>/dev/null || echo 0)
+  REVIEWER_PROMPT="${REVIEWER_PROMPT_BASE}${TARGET_SCOPE_PROMPT}"
 
   case "${PROVIDER_CMD}" in
     claude)
-      CLAUDE_PROMPT="/night-watch-pr-reviewer${TARGET_SCOPE_PROMPT}"
       if (
         cd "${REVIEW_WORKTREE_DIR}" && timeout "${ATTEMPT_TIMEOUT}" \
-          claude -p "${CLAUDE_PROMPT}" \
+          claude -p "${REVIEWER_PROMPT}" \
             --dangerously-skip-permissions \
             >> "${LOG_FILE}" 2>&1
       ); then
@@ -534,12 +711,11 @@ for ATTEMPT in $(seq 1 "${TOTAL_ATTEMPTS}"); do
       fi
       ;;
     codex)
-      CODEX_PROMPT="$(cat "${REVIEW_WORKTREE_DIR}/.claude/commands/night-watch-pr-reviewer.md")${TARGET_SCOPE_PROMPT}"
       if (
         cd "${REVIEW_WORKTREE_DIR}" && timeout "${ATTEMPT_TIMEOUT}" \
           codex --quiet \
             --yolo \
-            --prompt "${CODEX_PROMPT}" \
+            --prompt "${REVIEWER_PROMPT}" \
             >> "${LOG_FILE}" 2>&1
       ); then
         EXIT_CODE=0
@@ -553,8 +729,16 @@ for ATTEMPT in $(seq 1 "${TOTAL_ATTEMPTS}"); do
       ;;
   esac
 
-  # If provider failed (non-zero exit), don't retry
+  # If provider failed (non-zero exit), check for rate limit before giving up
   if [ "${EXIT_CODE}" -ne 0 ]; then
+    if [ "${EXIT_CODE}" -ne 124 ] && \
+       check_rate_limited "${LOG_FILE}" "${LOG_LINE_BEFORE}" && \
+       [ -n "${TARGET_PR}" ] && \
+       [ "${ATTEMPT}" -lt "${TOTAL_ATTEMPTS}" ]; then
+      log "RATE-LIMITED: 429 detected for PR #${TARGET_PR} (attempt ${ATTEMPT}/${TOTAL_ATTEMPTS}), retrying in 120s..."
+      sleep 120
+      continue
+    fi
     log "RETRY: Provider exited with code ${EXIT_CODE}, not retrying"
     break
   fi
@@ -585,7 +769,7 @@ for ATTEMPT in $(seq 1 "${TOTAL_ATTEMPTS}"); do
   fi
 done
 
-cleanup_worktrees "${PROJECT_DIR}" "${REVIEW_WORKTREE_BASENAME}"
+cleanup_reviewer_worktrees "${REVIEW_WORKTREE_BASENAME}"
 
 # ── Auto-merge eligible PRs ─────────────────────────────────────────────────────
 # After the reviewer completes, check for PRs that are merge-ready and queue them

package/dist/scripts/night-watch-qa-cron.sh

@@ -217,11 +217,21 @@ Artifacts: ${QA_ARTIFACTS}"
     continue
   fi
 
+  QA_PROMPT_PATH=$(resolve_instruction_path "${QA_WORKTREE_DIR}" "night-watch-qa.md" || true)
+  if [ -z "${QA_PROMPT_PATH}" ]; then
+    log "FAIL: Missing QA prompt file for PR #${pr_num}. Checked instructions/, .claude/commands/, and bundled templates/"
+    EXIT_CODE=1
+    break
+  fi
+  QA_PROMPT=$(cat "${QA_PROMPT_PATH}")
+  QA_PROMPT_REF=$(instruction_ref_for_prompt "${QA_WORKTREE_DIR}" "${QA_PROMPT_PATH}")
+  log "QA: PR #${pr_num} — using prompt from ${QA_PROMPT_REF}"
+
   case "${PROVIDER_CMD}" in
     claude)
       if (
         cd "${QA_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
-          claude -p "/night-watch-qa" \
+          claude -p "${QA_PROMPT}" \
             --dangerously-skip-permissions \
             >> "${LOG_FILE}" 2>&1
       ); then
@@ -241,7 +251,7 @@ Artifacts: ${QA_ARTIFACTS}"
         cd "${QA_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
           codex --quiet \
             --yolo \
-            --prompt "$(cat "${QA_WORKTREE_DIR}/.claude/commands/night-watch-qa.md")" \
+            --prompt "${QA_PROMPT}" \
             >> "${LOG_FILE}" 2>&1
       ); then
         log "QA: PR #${pr_num} — provider completed successfully"