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

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

@@ -28,6 +28,24 @@ TARGET_PR="${NW_TARGET_PR:-}"
 PARALLEL_ENABLED="${NW_REVIEWER_PARALLEL:-1}"
 WORKER_MODE="${NW_REVIEWER_WORKER_MODE:-0}"
 
+# Retry configuration
+REVIEWER_MAX_RETRIES="${NW_REVIEWER_MAX_RETRIES:-2}"
+REVIEWER_RETRY_DELAY="${NW_REVIEWER_RETRY_DELAY:-30}"
+
+# Normalize retry settings to safe numeric ranges
+if ! [[ "${REVIEWER_MAX_RETRIES}" =~ ^[0-9]+$ ]]; then
+  REVIEWER_MAX_RETRIES="2"
+fi
+if ! [[ "${REVIEWER_RETRY_DELAY}" =~ ^[0-9]+$ ]]; then
+  REVIEWER_RETRY_DELAY="30"
+fi
+if [ "${REVIEWER_MAX_RETRIES}" -gt 10 ]; then
+  REVIEWER_MAX_RETRIES="10"
+fi
+if [ "${REVIEWER_RETRY_DELAY}" -gt 300 ]; then
+  REVIEWER_RETRY_DELAY="300"
+fi
+
 # Ensure NVM / Node / Claude are on PATH
 export NVM_DIR="${HOME}/.nvm"
 [ -s "${NVM_DIR}/nvm.sh" ] && . "${NVM_DIR}/nvm.sh"
@@ -64,16 +82,31 @@ emit_final_status() {
   local prs_csv="${2:-}"
   local auto_merged="${3:-}"
   local auto_merge_failed="${4:-}"
+  local attempts="${5:-1}"
+  local final_score="${6:-}"
+  local details=""
 
   if [ "${exit_code}" -eq 0 ]; then
+    details="prs=${prs_csv}|auto_merged=${auto_merged}|auto_merge_failed=${auto_merge_failed}|attempts=${attempts}"
+    if [ -n "${final_score}" ]; then
+      details="${details}|final_score=${final_score}"
+    fi
     log "DONE: PR reviewer completed successfully"
-    emit_result "success_reviewed" "prs=${prs_csv}|auto_merged=${auto_merged}|auto_merge_failed=${auto_merge_failed}"
+    emit_result "success_reviewed" "${details}"
   elif [ "${exit_code}" -eq 124 ]; then
+    details="prs=${prs_csv}|attempts=${attempts}"
+    if [ -n "${final_score}" ]; then
+      details="${details}|final_score=${final_score}"
+    fi
     log "TIMEOUT: PR reviewer killed after ${MAX_RUNTIME}s"
-    emit_result "timeout" "prs=${prs_csv}"
+    emit_result "timeout" "${details}"
   else
+    details="prs=${prs_csv}|attempts=${attempts}"
+    if [ -n "${final_score}" ]; then
+      details="${details}|final_score=${final_score}"
+    fi
     log "FAIL: PR reviewer exited with code ${exit_code}"
-    emit_result "failure" "prs=${prs_csv}"
+    emit_result "failure" "${details}"
   fi
 }
 
@@ -91,6 +124,25 @@ append_csv() {
   fi
 }
 
+# Extract the latest review score from PR comments
+# Returns empty string if no score found
+get_pr_score() {
+  local pr_number="${1:?PR number required}"
+  local all_comments
+  all_comments=$(
+    {
+      gh pr view "${pr_number}" --json comments --jq '.comments[].body' 2>/dev/null || true
+      if [ -n "${REPO:-}" ]; then
+        gh api "repos/${REPO}/issues/${pr_number}/comments" --jq '.[].body' 2>/dev/null || true
+      fi
+    } | sort -u
+  )
+  echo "${all_comments}" \
+    | grep -oP 'Overall Score:\*?\*?\s*(\d+)/100' \
+    | tail -1 \
+    | grep -oP '\d+(?=/100)' || echo ""
+}
+
 # Validate provider
 if ! validate_provider "${PROVIDER_CMD}"; then
   echo "ERROR: Unknown provider: ${PROVIDER_CMD}" >&2
@@ -323,6 +375,8 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
   EXIT_CODE=0
   AUTO_MERGED_PRS=""
   AUTO_MERGE_FAILED_PRS=""
+  MAX_WORKER_ATTEMPTS=1
+  MAX_WORKER_FINAL_SCORE=""
 
   for idx in "${!WORKER_PIDS[@]}"; do
     worker_pid="${WORKER_PIDS[$idx]}"
@@ -344,10 +398,21 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
     worker_status=$(printf '%s' "${worker_result}" | sed -n 's/^NIGHT_WATCH_RESULT:\([^|]*\).*$/\1/p')
     worker_auto_merged=$(printf '%s' "${worker_result}" | grep -oP '(?<=auto_merged=)[^|]+' || true)
     worker_auto_merge_failed=$(printf '%s' "${worker_result}" | grep -oP '(?<=auto_merge_failed=)[^|]+' || true)
+    worker_attempts=$(printf '%s' "${worker_result}" | grep -oP '(?<=attempts=)[^|]+' || true)
+    worker_final_score=$(printf '%s' "${worker_result}" | grep -oP '(?<=final_score=)[^|]+' || true)
 
     AUTO_MERGED_PRS=$(append_csv "${AUTO_MERGED_PRS}" "${worker_auto_merged}")
     AUTO_MERGE_FAILED_PRS=$(append_csv "${AUTO_MERGE_FAILED_PRS}" "${worker_auto_merge_failed}")
 
+    if [[ "${worker_attempts}" =~ ^[0-9]+$ ]] && [ "${worker_attempts}" -gt "${MAX_WORKER_ATTEMPTS}" ]; then
+      MAX_WORKER_ATTEMPTS="${worker_attempts}"
+    fi
+    if [[ "${worker_final_score}" =~ ^[0-9]+$ ]]; then
+      if [ -z "${MAX_WORKER_FINAL_SCORE}" ] || [ "${worker_final_score}" -gt "${MAX_WORKER_FINAL_SCORE}" ]; then
+        MAX_WORKER_FINAL_SCORE="${worker_final_score}"
+      fi
+    fi
+
     rm -f "${worker_output}"
 
     if [ "${worker_status}" = "failure" ] || { [ -n "${worker_status}" ] && [ "${worker_status}" != "success_reviewed" ] && [ "${worker_status}" != "timeout" ] && [ "${worker_status#skip_}" = "${worker_status}" ]; }; then
@@ -374,7 +439,7 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
     fi
   done
 
-  emit_final_status "${EXIT_CODE}" "${PRS_NEEDING_WORK_CSV}" "${AUTO_MERGED_PRS}" "${AUTO_MERGE_FAILED_PRS}"
+  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
 
@@ -396,6 +461,8 @@ if [ "${NW_DRY_RUN:-0}" = "1" ]; then
   if [ "${AUTO_MERGE}" = "1" ]; then
     echo "Auto-merge Method: ${AUTO_MERGE_METHOD}"
   fi
+  echo "Max Retries: ${REVIEWER_MAX_RETRIES}"
+  echo "Retry Delay: ${REVIEWER_RETRY_DELAY}s"
   echo "Open PRs needing work:${PRS_NEEDING_WORK}"
   echo "Default Branch: ${DEFAULT_BRANCH}"
   echo "Review Worktree: ${REVIEW_WORKTREE_DIR}"
@@ -413,44 +480,110 @@ if ! prepare_detached_worktree "${PROJECT_DIR}" "${REVIEW_WORKTREE_DIR}" "${DEFA
 fi
 
 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'
 fi
 
-case "${PROVIDER_CMD}" in
-  claude)
-    CLAUDE_PROMPT="/night-watch-pr-reviewer${TARGET_SCOPE_PROMPT}"
-    if (
-      cd "${REVIEW_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
-        claude -p "${CLAUDE_PROMPT}" \
-          --dangerously-skip-permissions \
-          >> "${LOG_FILE}" 2>&1
-    ); then
-      EXIT_CODE=0
-    else
-      EXIT_CODE=$?
+# ── Retry Loop for Targeted PR Review ──────────────────────────────────────────
+# Only retry when targeting a specific PR. Non-targeted mode handles all PRs in one shot.
+TOTAL_ATTEMPTS=1
+if [ -n "${TARGET_PR}" ]; then
+  TOTAL_ATTEMPTS=$((REVIEWER_MAX_RETRIES + 1))
+fi
+RUN_STARTED_AT=$(date +%s)
+
+for ATTEMPT in $(seq 1 "${TOTAL_ATTEMPTS}"); do
+  ATTEMPTS_MADE="${ATTEMPT}"
+
+  ATTEMPT_TIMEOUT="${MAX_RUNTIME}"
+  if [ -n "${TARGET_PR}" ]; then
+    # Calculate timeout from remaining runtime budget.
+    NOW_TS=$(date +%s)
+    ELAPSED=$((NOW_TS - RUN_STARTED_AT))
+    REMAINING_BUDGET=$((MAX_RUNTIME - ELAPSED))
+    if [ "${REMAINING_BUDGET}" -le 0 ]; then
+      EXIT_CODE=124
+      log "RETRY: Runtime budget exhausted before attempt ${ATTEMPT}"
+      break
     fi
-    ;;
-  codex)
-    CODEX_PROMPT="$(cat "${REVIEW_WORKTREE_DIR}/.claude/commands/night-watch-pr-reviewer.md")${TARGET_SCOPE_PROMPT}"
-    if (
-      cd "${REVIEW_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
-        codex --quiet \
-          --yolo \
-          --prompt "${CODEX_PROMPT}" \
-          >> "${LOG_FILE}" 2>&1
-    ); then
-      EXIT_CODE=0
+
+    REMAINING_ATTEMPTS=$((TOTAL_ATTEMPTS - ATTEMPT + 1))
+    ATTEMPT_TIMEOUT=$((REMAINING_BUDGET / REMAINING_ATTEMPTS))
+    if [ "${ATTEMPT_TIMEOUT}" -lt 1 ]; then
+      ATTEMPT_TIMEOUT=1
+    fi
+  fi
+
+  log "RETRY: Starting attempt ${ATTEMPT}/${TOTAL_ATTEMPTS} (timeout: ${ATTEMPT_TIMEOUT}s)"
+
+  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}" \
+            --dangerously-skip-permissions \
+            >> "${LOG_FILE}" 2>&1
+      ); then
+        EXIT_CODE=0
+      else
+        EXIT_CODE=$?
+      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}" \
+            >> "${LOG_FILE}" 2>&1
+      ); then
+        EXIT_CODE=0
+      else
+        EXIT_CODE=$?
+      fi
+      ;;
+    *)
+      log "ERROR: Unknown provider: ${PROVIDER_CMD}"
+      exit 1
+      ;;
+  esac
+
+  # If provider failed (non-zero exit), don't retry
+  if [ "${EXIT_CODE}" -ne 0 ]; then
+    log "RETRY: Provider exited with code ${EXIT_CODE}, not retrying"
+    break
+  fi
+
+  # Re-check score for the target PR (only in targeted mode)
+  if [ -n "${TARGET_PR}" ]; then
+    CURRENT_SCORE=$(get_pr_score "${TARGET_PR}")
+    if [ -z "${CURRENT_SCORE}" ]; then
+      log "RETRY: No review score found for PR #${TARGET_PR} after attempt ${ATTEMPT}; not retrying"
+      break
+    fi
+
+    FINAL_SCORE="${CURRENT_SCORE}"
+    if [ "${CURRENT_SCORE}" -ge "${MIN_REVIEW_SCORE}" ]; then
+      log "RETRY: PR #${TARGET_PR} now scores ${CURRENT_SCORE}/100 (>= ${MIN_REVIEW_SCORE}) after attempt ${ATTEMPT}"
+      break
+    fi
+    if [ "${ATTEMPT}" -lt "${TOTAL_ATTEMPTS}" ]; then
+      log "RETRY: PR #${TARGET_PR} scores ${CURRENT_SCORE:-unknown}/100 after attempt ${ATTEMPT}/${TOTAL_ATTEMPTS}, retrying in ${REVIEWER_RETRY_DELAY}s..."
+      sleep "${REVIEWER_RETRY_DELAY}"
     else
-      EXIT_CODE=$?
+      log "RETRY: PR #${TARGET_PR} still at ${CURRENT_SCORE:-unknown}/100 after ${TOTAL_ATTEMPTS} attempts - giving up"
+      gh pr edit "${TARGET_PR}" --add-label "needs-human-review" 2>/dev/null || true
     fi
-    ;;
-  *)
-    log "ERROR: Unknown provider: ${PROVIDER_CMD}"
-    exit 1
-    ;;
-esac
+  else
+    # Non-targeted mode: no retry (reviewer handles all PRs in one shot)
+    break
+  fi
+done
 
 cleanup_worktrees "${PROJECT_DIR}" "${REVIEW_WORKTREE_BASENAME}"
 
@@ -529,4 +662,4 @@ if [ "${AUTO_MERGE}" = "1" ] && [ ${EXIT_CODE} -eq 0 ]; then
   done < <(gh pr list --state open --json number,headRefName --jq '.[] | [.number, .headRefName] | @tsv' 2>/dev/null || true)
 fi
 
-emit_final_status "${EXIT_CODE}" "${PRS_NEEDING_WORK_CSV}" "${AUTO_MERGED_PRS}" "${AUTO_MERGE_FAILED_PRS}"
+emit_final_status "${EXIT_CODE}" "${PRS_NEEDING_WORK_CSV}" "${AUTO_MERGED_PRS}" "${AUTO_MERGE_FAILED_PRS}" "${ATTEMPTS_MADE}" "${FINAL_SCORE}"

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

@@ -68,6 +68,10 @@ fi
 
 cd "${PROJECT_DIR}"
 
+send_telegram_status_message "🧪 Night Watch QA: started" "Project: ${PROJECT_NAME}
+Provider: ${PROVIDER_CMD}
+Scanning open PRs for QA candidates."
+
 # Convert comma-separated branch prefixes into a regex that matches branch starts.
 BRANCH_REGEX=""
 IFS=',' read -r -a BRANCH_PATTERNS <<< "${BRANCH_PATTERNS_RAW}"
@@ -96,6 +100,8 @@ OPEN_PRS=$(
 
 if [ "${OPEN_PRS}" -eq 0 ]; then
   log "SKIP: No open PRs matching branch patterns (${BRANCH_PATTERNS_RAW})"
+  send_telegram_status_message "🧪 Night Watch QA: no matching PRs" "Project: ${PROJECT_NAME}
+Branch patterns: ${BRANCH_PATTERNS_RAW}"
   emit_result "skip_no_open_prs"
   exit 0
 fi
@@ -151,6 +157,8 @@ done < <(
 
 if [ "${QA_NEEDED}" -eq 0 ]; then
   log "SKIP: All ${OPEN_PRS} open PR(s) matching patterns already have QA comments"
+  send_telegram_status_message "🧪 Night Watch QA: nothing to do" "Project: ${PROJECT_NAME}
+All matching PRs already have QA results."
   emit_result "skip_all_qa_done"
   exit 0
 fi
@@ -190,6 +198,9 @@ EXIT_CODE=0
 # Process each PR that needs QA
 for pr_ref in ${PRS_NEEDING_QA}; do
   pr_num="${pr_ref#\#}"
+  send_telegram_status_message "🧪 Night Watch QA: processing PR #${pr_num}" "Project: ${PROJECT_NAME}
+Provider: ${PROVIDER_CMD}
+Artifacts: ${QA_ARTIFACTS}"
 
   cleanup_worktrees "${PROJECT_DIR}"
   if ! prepare_detached_worktree "${PROJECT_DIR}" "${QA_WORKTREE_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
@@ -257,6 +268,8 @@ cleanup_worktrees "${PROJECT_DIR}"
 
 if [ ${EXIT_CODE} -eq 0 ]; then
   log "DONE: QA runner completed successfully"
+  send_telegram_status_message "🧪 Night Watch QA: completed" "Project: ${PROJECT_NAME}
+Processed PRs: ${PRS_NEEDING_QA_CSV}"
   if [ -n "${REPO}" ]; then
     emit_result "success_qa" "prs=${PRS_NEEDING_QA_CSV}|repo=${REPO}"
   else
@@ -264,6 +277,9 @@ if [ ${EXIT_CODE} -eq 0 ]; then
   fi
 elif [ ${EXIT_CODE} -eq 124 ]; then
   log "TIMEOUT: QA runner killed after ${MAX_RUNTIME}s"
+  send_telegram_status_message "🧪 Night Watch QA: timeout" "Project: ${PROJECT_NAME}
+Timeout: ${MAX_RUNTIME}s
+Processed PRs: ${PRS_NEEDING_QA_CSV}"
   if [ -n "${REPO}" ]; then
     emit_result "timeout" "prs=${PRS_NEEDING_QA_CSV}|repo=${REPO}"
   else
@@ -271,6 +287,9 @@ elif [ ${EXIT_CODE} -eq 124 ]; then
   fi
 else
   log "FAIL: QA runner exited with code ${EXIT_CODE}"
+  send_telegram_status_message "🧪 Night Watch QA: failed" "Project: ${PROJECT_NAME}
+Exit code: ${EXIT_CODE}
+Processed PRs: ${PRS_NEEDING_QA_CSV}"
   if [ -n "${REPO}" ]; then
     emit_result "failure" "prs=${PRS_NEEDING_QA_CSV}|repo=${REPO}"
   else

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

@@ -17,7 +17,7 @@ set -euo pipefail
 PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
-LOG_FILE="${LOG_DIR}/night-watch-slicer.log"
+LOG_FILE="${LOG_DIR}/slicer.log"
 LOCK_FILE=""
 MAX_RUNTIME="${NW_SLICER_MAX_RUNTIME:-600}"  # 10 minutes
 MAX_LOG_SIZE="524288"  # 512 KB
@@ -54,6 +54,9 @@ cleanup_on_exit() {
 trap cleanup_on_exit EXIT
 
 log "START: Running roadmap slicer for ${PROJECT_DIR}"
+send_telegram_status_message "📋 Night Watch Planner: started" "Project: ${PROJECT_NAME}
+Provider: ${PROVIDER_CMD}
+Planning next roadmap item into a PRD."
 
 # Dry-run mode: print diagnostics and exit
 if [ "${NW_DRY_RUN:-0}" = "1" ]; then
@@ -81,10 +84,16 @@ fi
 
 if [ ${EXIT_CODE} -eq 0 ]; then
   log "DONE: Slicer completed successfully"
+  send_telegram_status_message "📋 Night Watch Planner: completed" "Project: ${PROJECT_NAME}
+PRD planning run finished successfully."
 elif [ ${EXIT_CODE} -eq 124 ]; then
   log "TIMEOUT: Slicer killed after ${MAX_RUNTIME}s"
+  send_telegram_status_message "📋 Night Watch Planner: timeout" "Project: ${PROJECT_NAME}
+Timeout: ${MAX_RUNTIME}s"
 else
   log "FAIL: Slicer exited with code ${EXIT_CODE}"
+  send_telegram_status_message "📋 Night Watch Planner: failed" "Project: ${PROJECT_NAME}
+Exit code: ${EXIT_CODE}"
 fi
 
 exit ${EXIT_CODE}

package/dist/templates/night-watch-slicer.md

@@ -21,6 +21,8 @@ The PRD directory is: `{{PRD_DIR}}`
 
 ## Your Task
 
+0. **Load Planner Skill** - Read and apply `.claude/skills/prd-creator/SKILL.md` before writing the PRD. If unavailable, continue with the instructions in this template.
+
 1. **Explore the Codebase** - Read relevant existing files to understand the project structure, patterns, and conventions. Look for:
    - CLAUDE.md or similar AI assistant documentation files
    - Existing code patterns in the area you'll be modifying
@@ -61,7 +63,7 @@ COMPLEXITY SCORE (sum all that apply):
 
 Your PRD MUST follow this exact structure:
 
-```markdown
+````markdown
 # PRD: [Title from roadmap item]
 
 **Depends on:** [List any prerequisite PRDs/files, or omit if none]
@@ -77,24 +79,29 @@ Your PRD MUST follow this exact structure:
 **Problem:** [1-2 sentences describing the issue being solved]
 
 **Files Analyzed:**
+
 - `path/to/file.ts` — [what the file does]
 - [List all files you inspected before planning]
 
 **Current Behavior:**
+
 - [3-5 bullets describing current state]
 
 ### Integration Points Checklist
 
 **How will this feature be reached?**
+
 - [ ] Entry point identified: [e.g., route, event, cron, CLI command]
 - [ ] Caller file identified: [file that will invoke this new code]
 - [ ] Registration/wiring needed: [e.g., add route to router, register handler, add menu item]
 
 **Is this user-facing?**
+
 - [ ] YES → UI components required (list them)
 - [ ] NO → Internal/background feature (explain how it's triggered)
 
 **Full user flow:**
+
 1. User does: [action]
 2. Triggers: [what code path]
 3. Reaches new feature via: [specific connection point]
@@ -105,6 +112,7 @@ Your PRD MUST follow this exact structure:
 ## 2. Solution
 
 **Approach:**
+
 - [3-5 bullets explaining the chosen solution]
 
 **Architecture Diagram** <!-- (MEDIUM/HIGH complexity) -->:
@@ -113,8 +121,10 @@ Your PRD MUST follow this exact structure:
 flowchart LR
     A[Component A] --> B[Component B] --> C[Component C]
 ```
+````
 
 **Key Decisions:**
+
 - [Library/framework choices, error-handling strategy, reused utilities]
 
 **Data Changes:** [New schemas/migrations, or "None"]
@@ -140,6 +150,7 @@ sequenceDiagram
 ## 4. Execution Phases
 
 **CRITICAL RULES:**
+
 1. Each phase = ONE user-testable vertical slice
 2. Max 5 files per phase (split if larger)
 3. Each phase MUST include concrete tests
@@ -148,9 +159,11 @@ sequenceDiagram
 ### Phase 1: [Name] — [User-visible outcome in 1 sentence]
 
 **Files (max 5):**
+
 - `src/path/file.ts` — [what changes]
 
 **Implementation:**
+
 - [ ] Step 1
 - [ ] Step 2
 
@@ -160,6 +173,7 @@ sequenceDiagram
 | `src/__tests__/feature.test.ts` | `should do X when Y` | `expect(result).toBe(Z)` |
 
 **Verification Plan:**
+
 1. **Unit Tests:** File and test names
 2. **Integration Test:** (if applicable)
 3. **User Verification:**
@@ -183,7 +197,8 @@ sequenceDiagram
 - [ ] Feature is reachable (entry point connected, not orphaned code)
 - [ ] [additional criterion specific to this feature]
 - [ ] [additional criterion specific to this feature]
-```
+
+````
 
 ---
 
@@ -216,4 +231,4 @@ After writing the PRD file, report:
 
 ### Summary
 [1-2 sentences summarizing the PRD content]
-```
+````

package/dist/templates/night-watch.config.json

@@ -3,6 +3,7 @@
   "projectName": "",
   "defaultBranch": "",
   "provider": "claude",
+  "executorEnabled": true,
   "reviewerEnabled": true,
   "prdDir": "docs/PRDs/night-watch",
   "templatesDir": ".night-watch/templates",

package/dist/templates/night-watch.md

@@ -2,9 +2,9 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
 
 ## Instructions
 
-1. **Scan for PRDs**: List files in `docs/PRDs/night-watch/` (exclude `NIGHT-WATCH-SUMMARY.md` and the `done/` directory). Each `.md` file is a ticket.
+1. **Scan for PRDs**: Use `night-watch prd list --json` to get available PRDs. Each PRD is a ticket.
 
-2. **Check dependencies**: Read each PRD. If it says "Depends on:" another PRD, check if that dependency is already in `docs/PRDs/night-watch/done/`. Skip PRDs with unmet dependencies.
+2. **Check dependencies**: For each PRD, verify its dependencies are satisfied (depended-on PRD is marked as done). Skip PRDs with unmet dependencies.
 
 3. **Check for already-in-progress PRDs**: Before processing any PRD, check if a PR already exists for it:
 
@@ -30,11 +30,11 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
    d. `cd` into the worktree and run package install (npm install, yarn install, or pnpm install as appropriate). Keep all implementation steps inside this worktree.
 
    e. **Implement the PRD using the PRD Executor workflow**:
-      - Read `.claude/commands/prd-executor.md` and follow its full execution pipeline.
-      - This means: parse the PRD phases, build a dependency graph, create a task list, and execute phases in parallel waves using agent swarms.
-      - Maximize parallelism — launch all independent phases concurrently.
-      - Run the project's verify/test command between waves to catch issues early.
-      - Follow all project conventions from AI assistant documentation files (e.g., CLAUDE.md, AGENTS.md, or similar).
+   - Read `.claude/skills/prd-executor/SKILL.md` (preferred) or `.claude/commands/prd-executor.md` (fallback), and follow the full execution pipeline.
+   - This means: parse the PRD phases, build a dependency graph, create a task list, and execute phases in parallel waves using agent swarms.
+   - Maximize parallelism — launch all independent phases concurrently.
+   - Run the project's verify/test command between waves to catch issues early.
+   - Follow all project conventions from AI assistant documentation files (e.g., CLAUDE.md, AGENTS.md, or similar).
 
    f. **Write tests** as specified in each PRD phase (the prd-executor agents handle this per-phase).
 
@@ -58,37 +58,10 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
    gh pr create --title "feat: <short title>" --body "<summary with PRD reference>"
    ```
 
-   j. **Move PRD to done** (back in main repo on ${DEFAULT_BRANCH}):
+   j. **Mark PRD as done**: `night-watch prd done <filename>`
 
-   ```
-   cd ${PROJECT_DIR}
-   git checkout ${DEFAULT_BRANCH}
-   mkdir -p docs/PRDs/night-watch/done
-   mv docs/PRDs/night-watch/<file>.md docs/PRDs/night-watch/done/
-   ```
-
-   k. **Update summary**: Append to `docs/PRDs/night-watch/NIGHT-WATCH-SUMMARY.md`:
-
-   ```
-   ## <Title>
-   - **PRD**: <filename>
-   - **Branch**: night-watch/<name>
-   - **PR**: <url>
-   - **Date**: <YYYY-MM-DD>
-   - **Status**: PR Opened
-   ### What was done
-   <bullet points>
-   ### Files changed
-   <list>
-   ---
-   ```
-
-   l. **Commit** the move + summary update, push ${DEFAULT_BRANCH}.
-
-   m. **Clean up worktree**: `git worktree remove ../${PROJECT_NAME}-nw-<prd-name>`
-
-   n. **STOP after this PRD**. Do NOT continue to the next PRD. One PRD per run prevents timeouts and reduces risk. The next cron trigger will pick up the next PRD.
+   k. **STOP after this PRD**. Do NOT continue to the next PRD. One PRD per run prevents timeouts and reduces risk. The next cron trigger will pick up the next PRD.
 
-5. **On failure**: Do NOT move the PRD to done. Log the failure in NIGHT-WATCH-SUMMARY.md with status "Failed" and the reason. Clean up worktree and **stop** -- do not attempt the next PRD.
+5. **On failure**: Do NOT mark the PRD as done. Log the failure and clean up worktree. **Stop** -- do not attempt the next PRD.
 
 Start now. Scan for available PRDs and process the first eligible one.