@jonit-dev/night-watch-cli 1.7.45 → 1.7.47

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

@@ -58,6 +58,10 @@ if ! acquire_lock "${LOCK_FILE}"; then
   exit 0
 fi
 
+send_telegram_status_message "🔎 Night Watch Auditor: started" "Project: ${PROJECT_NAME}
+Provider: ${PROVIDER_CMD}
+Running code quality audit."
+
 # Dry-run mode: print diagnostics and exit
 if [ "${NW_DRY_RUN:-0}" = "1" ]; then
   echo "=== Dry Run: Code Auditor ==="
@@ -71,6 +75,9 @@ fi
 
 if [ ! -f "${AUDIT_PROMPT_TEMPLATE}" ]; then
   log "FAIL: Missing bundled audit prompt template at ${AUDIT_PROMPT_TEMPLATE}"
+  send_telegram_status_message "🔎 Night Watch Auditor: failed" "Project: ${PROJECT_NAME}
+Missing prompt template:
+${AUDIT_PROMPT_TEMPLATE}"
   emit_result "failure_missing_prompt"
   exit 1
 fi
@@ -90,6 +97,8 @@ cleanup_worktrees "${PROJECT_DIR}" "${AUDIT_WORKTREE_BASENAME}"
 
 if ! prepare_detached_worktree "${PROJECT_DIR}" "${AUDIT_WORKTREE_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
   log "FAIL: Unable to create isolated audit worktree ${AUDIT_WORKTREE_DIR}"
+  send_telegram_status_message "🔎 Night Watch Auditor: failed" "Project: ${PROJECT_NAME}
+Failed to create audit worktree."
   emit_result "failure" "reason=worktree_setup_failed"
   exit 1
 fi
@@ -146,22 +155,32 @@ cleanup_worktrees "${PROJECT_DIR}" "${AUDIT_WORKTREE_BASENAME}"
 if [ "${EXIT_CODE}" -eq 0 ]; then
   if [ ! -f "${REPORT_FILE}" ]; then
     log "FAIL: Audit provider exited 0 but no report was generated at ${REPORT_FILE}"
+    send_telegram_status_message "🔎 Night Watch Auditor: failed" "Project: ${PROJECT_NAME}
+Provider exited successfully but no report file was generated."
     emit_result "failure_no_report"
     exit 1
   fi
 
   if grep -q "NO_ISSUES_FOUND" "${REPORT_FILE}" 2>/dev/null; then
     log "DONE: Audit complete — no actionable issues found"
+    send_telegram_status_message "🔎 Night Watch Auditor: complete (clean)" "Project: ${PROJECT_NAME}
+No actionable issues found."
     emit_result "skip_clean"
   else
     log "DONE: Audit complete — report written to ${REPORT_FILE}"
+    send_telegram_status_message "🔎 Night Watch Auditor: complete" "Project: ${PROJECT_NAME}
+Report: ${REPORT_FILE}"
     emit_result "success_audit"
   fi
 elif [ "${EXIT_CODE}" -eq 124 ]; then
   log "TIMEOUT: Audit killed after ${MAX_RUNTIME}s"
+  send_telegram_status_message "🔎 Night Watch Auditor: timeout" "Project: ${PROJECT_NAME}
+Timeout: ${MAX_RUNTIME}s"
   emit_result "timeout"
 else
   log "FAIL: Audit exited with code ${EXIT_CODE}"
+  send_telegram_status_message "🔎 Night Watch Auditor: failed" "Project: ${PROJECT_NAME}
+Exit code: ${EXIT_CODE}"
   emit_result "failure" "provider_exit=${EXIT_CODE}"
 fi
 

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

@@ -74,6 +74,13 @@ if ! acquire_lock "${LOCK_FILE}"; then
   exit 0
 fi
 
+# Ensure all repo-scoped gh/night-watch commands run against this project.
+if ! cd "${PROJECT_DIR}"; then
+  log "ERROR: Cannot access project directory ${PROJECT_DIR}"
+  emit_result "failure" "reason=invalid_project_dir"
+  exit 1
+fi
+
 cleanup_worktrees "${PROJECT_DIR}"
 
 ISSUE_NUMBER=""    # board mode: GitHub issue number
@@ -221,7 +228,7 @@ ${ISSUE_BODY}
 - Install dependencies if needed and implement in the current worktree only
 
 ## Implementation — PRD Executor Workflow
-Read .claude/commands/prd-executor.md and follow its FULL execution pipeline:
+Read .claude/skills/prd-executor/SKILL.md (preferred) or .claude/commands/prd-executor.md (fallback), 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
@@ -249,7 +256,7 @@ else
 - Install dependencies if needed and implement in the current worktree only
 
 ## Implementation — PRD Executor Workflow
-Read .claude/commands/prd-executor.md and follow its FULL execution pipeline:
+Read .claude/skills/prd-executor/SKILL.md (preferred) or .claude/commands/prd-executor.md (fallback), 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

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

@@ -445,6 +445,52 @@ check_rate_limited() {
   fi
 }
 
+# Send a generic Telegram status message.
+# Preferred input: NW_TELEGRAM_STATUS_WEBHOOKS (JSON array with botToken/chatId).
+# Legacy fallback: NW_TELEGRAM_BOT_TOKEN + NW_TELEGRAM_CHAT_ID.
+# Usage: send_telegram_status_message <title> [body]
+send_telegram_status_message() {
+  local title="${1:-Night Watch}"
+  local body="${2:-}"
+  local msg="${title}"
+  if [ -n "${body}" ]; then
+    msg="${title}
+
+${body}"
+  fi
+
+  # Preferred path: iterate all configured Telegram webhooks.
+  if [ -n "${NW_TELEGRAM_STATUS_WEBHOOKS:-}" ] && command -v jq >/dev/null 2>&1; then
+    local sent=0
+    local webhook_json
+    while IFS= read -r webhook_json; do
+      [ -z "${webhook_json}" ] && continue
+      local bot_token
+      local chat_id
+      bot_token=$(printf '%s' "${webhook_json}" | jq -r '.botToken // empty' 2>/dev/null || true)
+      chat_id=$(printf '%s' "${webhook_json}" | jq -r '.chatId // empty' 2>/dev/null || true)
+      if [ -n "${bot_token}" ] && [ -n "${chat_id}" ]; then
+        curl -s -X POST "https://api.telegram.org/bot${bot_token}/sendMessage" \
+          --data-urlencode "chat_id=${chat_id}" \
+          --data-urlencode "text=${msg}" > /dev/null 2>&1 || true
+        sent=1
+      fi
+    done < <(printf '%s' "${NW_TELEGRAM_STATUS_WEBHOOKS}" | jq -c '.[]?' 2>/dev/null || true)
+
+    if [ "${sent}" -eq 1 ]; then
+      return 0
+    fi
+  fi
+
+  # Legacy single-webhook fallback.
+  if [ -z "${NW_TELEGRAM_BOT_TOKEN:-}" ] || [ -z "${NW_TELEGRAM_CHAT_ID:-}" ]; then
+    return 0
+  fi
+  curl -s -X POST "https://api.telegram.org/bot${NW_TELEGRAM_BOT_TOKEN}/sendMessage" \
+    --data-urlencode "chat_id=${NW_TELEGRAM_CHAT_ID}" \
+    --data-urlencode "text=${msg}" > /dev/null 2>&1 || true
+}
+
 # Send an immediate Telegram warning when the rate-limit fallback is triggered.
 # Preferred input: NW_TELEGRAM_RATE_LIMIT_WEBHOOKS (JSON array with botToken/chatId).
 # Legacy fallback: NW_TELEGRAM_BOT_TOKEN + NW_TELEGRAM_CHAT_ID.

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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jonit-dev/night-watch-cli",
-  "version": "1.7.45",
+  "version": "1.7.47",
   "description": "Autonomous PRD execution using AI Provider CLIs + cron",
   "type": "module",
   "bin": {