@jonit-dev/night-watch-cli 1.8.14-beta.0 → 1.8.14-beta.10

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

@@ -8,12 +8,14 @@ set -euo pipefail
 # (oldest PR first by creation date). Rebases remaining PRs after each merge.
 #
 # Required env vars (with defaults shown):
-#   NW_MERGER_MAX_RUNTIME=1800               - Maximum runtime in seconds (30 min)
+#   NW_MERGER_MAX_RUNTIME=0                  - Maximum runtime in seconds (0 = no timeout)
 #   NW_MERGER_MERGE_METHOD=squash            - Merge method: squash|merge|rebase
 #   NW_MERGER_MIN_REVIEW_SCORE=80            - Minimum review score threshold
 #   NW_MERGER_BRANCH_PATTERNS=               - Comma-separated branch prefixes (empty = all)
 #   NW_MERGER_REBASE_BEFORE_MERGE=1          - Set to 1 to rebase before merging
 #   NW_MERGER_MAX_PRS_PER_RUN=0             - Max PRs to merge per run (0 = unlimited)
+#   NW_MERGER_CI_POLICY=fallback-local      - CI gate: ci-only|fallback-local|ignore
+#   NW_MERGER_LOCAL_CHECK_COMMAND=...       - Command run in temp PR worktree for local fallback
 #   NW_MERGER_CI_MAX_WAIT=300                - Max seconds to wait for checks after rebase
 #   NW_MERGER_CI_POLL_INTERVAL=15            - Seconds between check polls after rebase
 #   NW_DRY_RUN=0                             - Set to 1 for dry-run mode
@@ -22,7 +24,7 @@ PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/merger.log"
-MAX_RUNTIME="${NW_MERGER_MAX_RUNTIME:-1800}"
+MAX_RUNTIME="${NW_MERGER_MAX_RUNTIME:-0}"
 MAX_LOG_SIZE="524288"  # 512 KB
 MERGE_METHOD="${NW_MERGER_MERGE_METHOD:-squash}"
 MIN_REVIEW_SCORE="${NW_MERGER_MIN_REVIEW_SCORE:-80}"
@@ -30,6 +32,8 @@ REBASE_BEFORE_MERGE="${NW_MERGER_REBASE_BEFORE_MERGE:-1}"
 MAX_PRS_PER_RUN="${NW_MERGER_MAX_PRS_PER_RUN:-0}"
 CI_MAX_WAIT="${NW_MERGER_CI_MAX_WAIT:-300}"
 CI_POLL_INTERVAL="${NW_MERGER_CI_POLL_INTERVAL:-15}"
+CI_POLICY="${NW_MERGER_CI_POLICY:-fallback-local}"
+LOCAL_CHECK_COMMAND="${NW_MERGER_LOCAL_CHECK_COMMAND:-yarn install --frozen-lockfile && yarn verify && yarn test}"
 BRANCH_PATTERNS_RAW="${NW_MERGER_BRANCH_PATTERNS:-}"
 READY_TO_MERGE_LABEL="${NW_PR_RESOLVER_READY_LABEL:-ready-to-merge}"
 SCRIPT_START_TIME=$(date +%s)
@@ -55,6 +59,10 @@ case "${MERGE_METHOD}" in
   squash|merge|rebase) ;;
   *) MERGE_METHOD="squash" ;;
 esac
+case "${CI_POLICY}" in
+  ci-only|fallback-local|ignore) ;;
+  *) CI_POLICY="fallback-local" ;;
+esac
 
 mkdir -p "${LOG_DIR}"
 
@@ -71,6 +79,7 @@ skip_if_job_paused "${SCRIPT_TYPE}" "${PROJECT_DIR}"
 MERGED_PRS=0
 FAILED_PRS=0
 MERGED_PR_LIST=""
+LAST_LOCAL_CHECK_OUTPUT=""
 
 emit_result() {
   local status="${1:?status required}"
@@ -261,6 +270,220 @@ wait_for_ci_passing_on_head() {
   [ "${LAST_CI_STATUS}" = "passing" ]
 }
 
+find_existing_worktree_for_head() {
+  local pr_branch="${1}"
+  local expected_head="${2}"
+  local project_real=""
+  local worktree_path=""
+  local branch=""
+  local head=""
+
+  project_real=$(cd "${PROJECT_DIR}" && pwd -P 2>/dev/null || echo "${PROJECT_DIR}")
+
+  while IFS= read -r line; do
+    if [[ "${line}" == worktree\ * ]]; then
+      worktree_path="${line#worktree }"
+      branch=""
+      head=""
+      continue
+    fi
+    if [[ "${line}" == HEAD\ * ]]; then
+      head="${line#HEAD }"
+      continue
+    fi
+    if [[ "${line}" == branch\ * ]]; then
+      branch="${line#branch refs/heads/}"
+      if [ -n "${worktree_path}" ] \
+        && [ "${branch}" = "${pr_branch}" ] \
+        && [ "${head}" = "${expected_head}" ] \
+        && [ -d "${worktree_path}" ]; then
+        local worktree_real=""
+        worktree_real=$(cd "${worktree_path}" && pwd -P 2>/dev/null || echo "${worktree_path}")
+        if [ "${worktree_real}" = "${project_real}" ]; then
+          continue
+        fi
+        if git -C "${worktree_path}" diff --quiet >/dev/null 2>&1 \
+          && git -C "${worktree_path}" diff --cached --quiet >/dev/null 2>&1; then
+          printf "%s" "${worktree_path}"
+          return 0
+        fi
+      fi
+    fi
+  done < <(git worktree list --porcelain 2>/dev/null || true)
+
+  return 1
+}
+
+run_local_check_command_in_dir() {
+  local pr_number="${1}"
+  local expected_head="${2}"
+  local check_dir="${3}"
+  local check_exit=1
+  local output_file=""
+
+  output_file=$(mktemp "${TMPDIR:-/tmp}/night-watch-merger-local-check-${pr_number}.XXXXXX")
+  LAST_LOCAL_CHECK_OUTPUT=""
+
+  set +e
+  (
+    cd "${check_dir}"
+    bash -lc "${LOCAL_CHECK_COMMAND}"
+  ) 2>&1 | tee "${output_file}" | tee -a "${LOG_FILE}"
+  check_exit=${PIPESTATUS[0]}
+  set -e
+
+  LAST_LOCAL_CHECK_OUTPUT=$(head -c 10000 "${output_file}" 2>/dev/null || true)
+  rm -f "${output_file}" 2>/dev/null || true
+
+  if [ "${check_exit}" -eq 0 ]; then
+    log "INFO: PR #${pr_number}: Local checks passed for head ${expected_head}"
+    return 0
+  fi
+
+  log "INFO: PR #${pr_number}: Local checks failed for head ${expected_head} (exit ${check_exit})"
+  return 1
+}
+
+run_local_checks_for_head() {
+  local pr_number="${1}"
+  local pr_branch="${2}"
+  local expected_head="${3}"
+  local temp_parent=""
+  local worktree_dir=""
+  local existing_worktree_dir=""
+  local temp_ref=""
+
+  if [ -z "${LOCAL_CHECK_COMMAND}" ]; then
+    log "INFO: PR #${pr_number}: Local check command is empty, treating fallback as failed"
+    return 1
+  fi
+
+  if existing_worktree_dir=$(find_existing_worktree_for_head "${pr_branch}" "${expected_head}"); then
+    log "INFO: PR #${pr_number}: Reusing existing worktree for local checks: ${existing_worktree_dir}"
+    run_local_check_command_in_dir "${pr_number}" "${expected_head}" "${existing_worktree_dir}"
+    return $?
+  fi
+
+  temp_parent=$(mktemp -d "${TMPDIR:-/tmp}/night-watch-merger-${pr_number}.XXXXXX")
+  worktree_dir="${temp_parent}/worktree"
+  temp_ref="refs/night-watch/merger/${pr_number}-${expected_head}"
+
+  cleanup_local_check_worktree() {
+    git worktree remove --force "${worktree_dir}" >/dev/null 2>&1 || true
+    git update-ref -d "${temp_ref}" >/dev/null 2>&1 || true
+    rm -rf "${temp_parent}" >/dev/null 2>&1 || true
+  }
+
+  log "INFO: PR #${pr_number}: Running local checks for head ${expected_head}: ${LOCAL_CHECK_COMMAND}"
+
+  if ! git cat-file -e "${expected_head}^{commit}" >/dev/null 2>&1; then
+    log "INFO: PR #${pr_number}: Fetching PR head ${expected_head} for local checks"
+    git fetch --quiet --force origin "pull/${pr_number}/head:${temp_ref}" >/dev/null 2>&1 || {
+      log "INFO: PR #${pr_number}: Unable to fetch PR head for local checks"
+      cleanup_local_check_worktree
+      return 1
+    }
+  fi
+
+  if ! git worktree add --detach --quiet "${worktree_dir}" "${expected_head}" >/dev/null 2>&1; then
+    if ! git worktree add --detach --quiet "${worktree_dir}" "${temp_ref}" >/dev/null 2>&1; then
+      log "INFO: PR #${pr_number}: Unable to create local check worktree"
+      cleanup_local_check_worktree
+      return 1
+    fi
+  fi
+
+  run_local_check_command_in_dir "${pr_number}" "${expected_head}" "${worktree_dir}"
+  local check_result=$?
+
+  cleanup_local_check_worktree
+
+  return "${check_result}"
+}
+
+run_reviewer_repair_for_pr() {
+  local pr_number="${1}"
+  local pr_branch="${2}"
+  local expected_head="${3}"
+  local elapsed=0
+  local remaining=0
+  local reviewer_exit=1
+
+  elapsed=$(( $(date +%s) - SCRIPT_START_TIME ))
+  if is_runtime_limited "${MAX_RUNTIME}"; then
+    remaining=$(( MAX_RUNTIME - elapsed - 30 ))
+  else
+    remaining=0
+  fi
+  if is_runtime_limited "${MAX_RUNTIME}" && [ "${remaining}" -lt 120 ]; then
+    log "INFO: PR #${pr_number} (${pr_branch}): Not enough merger runtime left for targeted reviewer repair (${remaining}s), skipping repair"
+    return 1
+  fi
+
+  log "INFO: PR #${pr_number} (${pr_branch}): Running targeted reviewer repair after local check failure on head ${expected_head}"
+
+  set +e
+  (
+    NW_TARGET_PR="${pr_number}" \
+    NW_REVIEWER_WORKER_MODE="1" \
+    NW_REVIEWER_PARALLEL="0" \
+    NW_REVIEWER_MAX_RUNTIME="${remaining}" \
+    NW_TARGET_LOCAL_CHECK_COMMAND="${LOCAL_CHECK_COMMAND}" \
+    NW_TARGET_LOCAL_CHECK_OUTPUT="${LAST_LOCAL_CHECK_OUTPUT}" \
+    bash "${SCRIPT_DIR}/night-watch-pr-reviewer-cron.sh" "${PROJECT_DIR}"
+  ) 2>&1 | tee -a "${LOG_FILE}"
+  reviewer_exit=${PIPESTATUS[0]}
+  set -e
+
+  if [ "${reviewer_exit}" -eq 0 ]; then
+    log "INFO: PR #${pr_number} (${pr_branch}): Targeted reviewer repair completed"
+    return 0
+  fi
+
+  log "INFO: PR #${pr_number} (${pr_branch}): Targeted reviewer repair failed (exit ${reviewer_exit})"
+  return 1
+}
+
+ci_gate_allows_head() {
+  local pr_number="${1}"
+  local pr_branch="${2}"
+  local expected_head="${3}"
+  local context="${4:-CI}"
+  local ci_status
+
+  if [ "${CI_POLICY}" = "ignore" ]; then
+    log "INFO: PR #${pr_number} (${pr_branch}): CI policy is ignore; skipping ${context} gate for head ${expected_head}"
+    return 0
+  fi
+
+  ci_status=$(ci_status_for_head "${pr_number}" "${expected_head}")
+  if [ "${ci_status}" = "passing" ]; then
+    return 0
+  fi
+
+  if [ "${CI_POLICY}" = "fallback-local" ]; then
+    log "INFO: PR #${pr_number} (${pr_branch}): ${context} not passing on head ${expected_head} (${ci_status}); trying local checks"
+    if run_local_checks_for_head "${pr_number}" "${pr_branch}" "${expected_head}"; then
+      return 0
+    fi
+    if run_reviewer_repair_for_pr "${pr_number}" "${pr_branch}" "${expected_head}"; then
+      local repaired_head=""
+      repaired_head=$(get_pr_head_oid "${pr_number}")
+      if [ -n "${repaired_head}" ]; then
+        log "INFO: PR #${pr_number} (${pr_branch}): Re-checking local checks after targeted repair on head ${repaired_head}"
+        if run_local_checks_for_head "${pr_number}" "${pr_branch}" "${repaired_head}"; then
+          return 0
+        fi
+      fi
+    fi
+    log "INFO: PR #${pr_number} (${pr_branch}): Local check fallback failed after repair attempt, skipping"
+    return 1
+  fi
+
+  log "INFO: PR #${pr_number} (${pr_branch}): ${context} not passing on head ${expected_head} (${ci_status}), skipping"
+  return 1
+}
+
 # Rebase a PR against its base branch
 rebase_pr() {
   local pr_number="${1}"
@@ -308,7 +531,7 @@ cd "${PROJECT_DIR}"
 
 log "========================================"
 log "RUN-START: merger invoked project=${PROJECT_DIR} dry_run=${DRY_RUN}"
-log "CONFIG: merge_method=${MERGE_METHOD} min_review_score=${MIN_REVIEW_SCORE} rebase_before_merge=${REBASE_BEFORE_MERGE} max_prs=${MAX_PRS_PER_RUN} max_runtime=${MAX_RUNTIME}s ready_label=${READY_TO_MERGE_LABEL} branch_patterns=${BRANCH_PATTERNS_RAW:-<all>}"
+log "CONFIG: merge_method=${MERGE_METHOD} min_review_score=${MIN_REVIEW_SCORE} rebase_before_merge=${REBASE_BEFORE_MERGE} max_prs=${MAX_PRS_PER_RUN} max_runtime=${MAX_RUNTIME}s ci_policy=${CI_POLICY} local_check_command=${LOCAL_CHECK_COMMAND} ready_label=${READY_TO_MERGE_LABEL} branch_patterns=${BRANCH_PATTERNS_RAW:-<all>}"
 log "========================================"
 
 if ! acquire_lock "${LOCK_FILE}"; then
@@ -331,13 +554,15 @@ if [ "${DRY_RUN}" = "1" ]; then
 fi
 
 # Timeout watchdog
-(
-  sleep "${MAX_RUNTIME}"
-  log "TIMEOUT: Merger exceeded ${MAX_RUNTIME}s, terminating"
-  kill -TERM $$ 2>/dev/null || true
-) &
-WATCHDOG_PID=$!
-append_exit_trap "cleanup_watchdog ${WATCHDOG_PID}"
+if is_runtime_limited "${MAX_RUNTIME}"; then
+  (
+    sleep "${MAX_RUNTIME}"
+    log "TIMEOUT: Merger exceeded ${MAX_RUNTIME}s, terminating"
+    kill -TERM $$ 2>/dev/null || true
+  ) &
+  WATCHDOG_PID=$!
+  append_exit_trap "cleanup_watchdog ${WATCHDOG_PID}"
+fi
 
 # Discover open PRs sorted by creation date (oldest first = FIFO)
 log "INFO: Scanning open PRs..."
@@ -391,10 +616,8 @@ while IFS= read -r pr_json; do
     continue
   fi
 
-  # Check CI status
-  ci_status=$(ci_status_for_head "${pr_number}" "${pr_head_oid}")
-  if [ "${ci_status}" != "passing" ]; then
-    log "INFO: PR #${pr_number} (${pr_branch}): CI not passing on head ${pr_head_oid} (${ci_status}), skipping"
+  # Check CI status, optionally falling back to local checks for provider/billing failures.
+  if ! ci_gate_allows_head "${pr_number}" "${pr_branch}" "${pr_head_oid}" "CI"; then
     continue
   fi
 
@@ -436,10 +659,22 @@ while IFS= read -r pr_json; do
       log "INFO: PR #${pr_number}: Head unchanged after rebase (${pr_head_after_rebase}); confirming CI"
     fi
 
-    # Poll CI until all checks attached to the post-rebase head are complete and passing.
-    if ! wait_for_ci_passing_on_head "${pr_number}" "${pr_head_after_rebase}"; then
-      log "INFO: PR #${pr_number}: Fresh CI not passing on head ${pr_head_after_rebase} after rebase (${LAST_CI_STATUS}, waited ${CI_MAX_WAIT}s), skipping"
-      continue
+    if [ "${CI_POLICY}" = "ignore" ]; then
+      log "INFO: PR #${pr_number}: CI policy is ignore; skipping fresh CI gate after rebase"
+    else
+      # Poll CI until all checks attached to the post-rebase head are complete and passing.
+      if ! wait_for_ci_passing_on_head "${pr_number}" "${pr_head_after_rebase}"; then
+        log "INFO: PR #${pr_number}: Fresh CI not passing on head ${pr_head_after_rebase} after rebase (${LAST_CI_STATUS}, waited ${CI_MAX_WAIT}s)"
+        if [ "${CI_POLICY}" = "fallback-local" ]; then
+          if ! run_local_checks_for_head "${pr_number}" "${pr_branch}" "${pr_head_after_rebase}"; then
+            log "INFO: PR #${pr_number}: Fresh local check fallback failed after rebase, skipping"
+            continue
+          fi
+        else
+          log "INFO: PR #${pr_number}: Skipping because CI policy requires GitHub CI"
+          continue
+        fi
+      fi
     fi
   fi
 
@@ -484,7 +719,7 @@ while IFS= read -r pr_json; do
 
   # Enforce global timeout
   elapsed=$(( $(date +%s) - SCRIPT_START_TIME ))
-  if [ "${elapsed}" -ge "${MAX_RUNTIME}" ]; then
+  if is_runtime_limited "${MAX_RUNTIME}" && [ "${elapsed}" -ge "${MAX_RUNTIME}" ]; then
     log "WARN: Global timeout reached (${MAX_RUNTIME}s), stopping early"
     break
   fi

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

@@ -9,7 +9,7 @@ set -euo pipefail
 # Required env vars (with defaults shown):
 #   NW_PLAN_TASK=''          - Task/feature description to plan (required)
 #   NW_PRD_DIR=docs/PRDs     - PRD output directory (relative to project)
-#   NW_PLAN_MAX_RUNTIME=1800 - Maximum runtime in seconds
+#   NW_PLAN_MAX_RUNTIME=0    - Maximum runtime in seconds (0 = no timeout)
 #   NW_PROVIDER_CMD=claude   - AI provider CLI to use
 #   NW_DRY_RUN=0             - Set to 1 for dry-run mode
 
@@ -18,7 +18,7 @@ PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/plan.log"
 LOCK_FILE=""
-MAX_RUNTIME="${NW_PLAN_MAX_RUNTIME:-1800}"
+MAX_RUNTIME="${NW_PLAN_MAX_RUNTIME:-0}"
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
 PROVIDER_LABEL="${NW_PROVIDER_LABEL:-}"
@@ -132,7 +132,7 @@ EXIT_CODE=0
 mapfile -d '' -t PROVIDER_CMD_PARTS < <(build_provider_cmd "${PROJECT_DIR}" "${CREATOR_PROMPT}")
 
 # Execute in the project directory so the provider can explore the codebase
-if (cd "${PROJECT_DIR}" && timeout "${MAX_RUNTIME}" "${PROVIDER_CMD_PARTS[@]}" 2>&1 | tee -a "${LOG_FILE}"); then
+if (cd "${PROJECT_DIR}" && run_with_optional_timeout "${MAX_RUNTIME}" "${PROVIDER_CMD_PARTS[@]}" 2>&1 | tee -a "${LOG_FILE}"); then
   EXIT_CODE=0
 else
   EXIT_CODE=$?

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

@@ -7,11 +7,11 @@ set -euo pipefail
 # NOTE: This script expects environment variables to be set by the caller.
 # The Node.js CLI will inject config values via environment variables.
 # Required env vars (with defaults shown):
-#   NW_PR_RESOLVER_MAX_RUNTIME=3600          - Maximum runtime in seconds (1 hour)
+#   NW_PR_RESOLVER_MAX_RUNTIME=0             - Maximum runtime in seconds (0 = no timeout)
 #   NW_PROVIDER_CMD=claude                   - AI provider CLI to use (claude, codex, etc.)
 #   NW_DRY_RUN=0                             - Set to 1 for dry-run mode (prints diagnostics only)
 #   NW_PR_RESOLVER_MAX_PRS_PER_RUN=0         - Max PRs to process per run (0 = unlimited)
-#   NW_PR_RESOLVER_PER_PR_TIMEOUT=600        - Per-PR AI timeout in seconds
+#   NW_PR_RESOLVER_PER_PR_TIMEOUT=0          - Per-PR AI timeout in seconds (0 = no timeout)
 #   NW_PR_RESOLVER_AI_CONFLICT_RESOLUTION=1  - Set to 1 to use AI for conflict resolution
 #   NW_PR_RESOLVER_AI_REVIEW_RESOLUTION=0    - Set to 1 to also address review comments
 #   NW_PR_RESOLVER_READY_LABEL=ready-to-merge - Label to add when PR is conflict-free
@@ -21,12 +21,12 @@ PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/pr-resolver.log"
-MAX_RUNTIME="${NW_PR_RESOLVER_MAX_RUNTIME:-3600}"  # 1 hour
+MAX_RUNTIME="${NW_PR_RESOLVER_MAX_RUNTIME:-0}"  # 0 = no global timeout
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
 PROVIDER_LABEL="${NW_PROVIDER_LABEL:-}"
 MAX_PRS_PER_RUN="${NW_PR_RESOLVER_MAX_PRS_PER_RUN:-0}"
-PER_PR_TIMEOUT="${NW_PR_RESOLVER_PER_PR_TIMEOUT:-600}"
+PER_PR_TIMEOUT="${NW_PR_RESOLVER_PER_PR_TIMEOUT:-0}"
 AI_CONFLICT_RESOLUTION="${NW_PR_RESOLVER_AI_CONFLICT_RESOLUTION:-1}"
 AI_REVIEW_RESOLUTION="${NW_PR_RESOLVER_AI_REVIEW_RESOLUTION:-0}"
 READY_LABEL="${NW_PR_RESOLVER_READY_LABEL:-ready-to-merge}"
@@ -38,14 +38,11 @@ if ! [[ "${MAX_PRS_PER_RUN}" =~ ^[0-9]+$ ]]; then
   MAX_PRS_PER_RUN="0"
 fi
 if ! [[ "${PER_PR_TIMEOUT}" =~ ^[0-9]+$ ]]; then
-  PER_PR_TIMEOUT="600"
+  PER_PR_TIMEOUT="0"
 fi
 if [ "${MAX_PRS_PER_RUN}" -gt 100 ]; then
   MAX_PRS_PER_RUN="100"
 fi
-if [ "${PER_PR_TIMEOUT}" -gt 3600 ]; then
-  PER_PR_TIMEOUT="3600"
-fi
 
 mkdir -p "${LOG_DIR}"
 
@@ -183,7 +180,7 @@ Work exclusively in the directory: ${worktree_dir}"
         local -a cmd_parts
         mapfile -d '' -t cmd_parts < <(build_provider_cmd "${worktree_dir}" "${ai_prompt}")
 
-        if timeout "${PER_PR_TIMEOUT}" "${cmd_parts[@]}" >> "${LOG_FILE}" 2>&1; then
+        if run_with_optional_timeout "${PER_PR_TIMEOUT}" "${cmd_parts[@]}" >> "${LOG_FILE}" 2>&1; then
           rebase_success=1
           log "INFO: AI resolved conflicts for PR #${pr_number}" "branch=${pr_branch}"
         else
@@ -241,7 +238,7 @@ Work in the directory: ${review_workdir}"
       local -a review_cmd_parts
       mapfile -d '' -t review_cmd_parts < <(build_provider_cmd "${review_workdir}" "${review_prompt}")
 
-      if timeout "${PER_PR_TIMEOUT}" "${review_cmd_parts[@]}" >> "${LOG_FILE}" 2>&1; then
+      if run_with_optional_timeout "${PER_PR_TIMEOUT}" "${review_cmd_parts[@]}" >> "${LOG_FILE}" 2>&1; then
         log "INFO: AI addressed review comments for PR #${pr_number}" "branch=${pr_branch}"
       else
         log "WARN: AI failed to address review comments for PR #${pr_number}" "branch=${pr_branch}"
@@ -379,7 +376,7 @@ while IFS= read -r pr_line; do
 
   # Enforce global timeout
   elapsed=$(( $(date +%s) - SCRIPT_START_TIME ))
-  if [ "${elapsed}" -ge "${MAX_RUNTIME}" ]; then
+  if is_runtime_limited "${MAX_RUNTIME}" && [ "${elapsed}" -ge "${MAX_RUNTIME}" ]; then
     log "WARN: Global timeout reached (${MAX_RUNTIME}s), stopping early"
     break
   fi

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

@@ -7,7 +7,7 @@ set -euo pipefail
 # NOTE: This script expects environment variables to be set by the caller.
 # The Node.js CLI will inject config values via environment variables.
 # Required env vars (with defaults shown):
-#   NW_REVIEWER_MAX_RUNTIME=3600 - Maximum runtime in seconds (1 hour)
+#   NW_REVIEWER_MAX_RUNTIME=0    - Maximum runtime in seconds (0 = no timeout)
 #   NW_PROVIDER_CMD=claude       - AI provider CLI to use (claude, codex, etc.)
 #   NW_DRY_RUN=0                 - Set to 1 for dry-run mode (prints diagnostics only)
 
@@ -15,7 +15,7 @@ PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/reviewer.log"
-MAX_RUNTIME="${NW_REVIEWER_MAX_RUNTIME:-3600}"  # 1 hour
+MAX_RUNTIME="${NW_REVIEWER_MAX_RUNTIME:-0}"  # 0 = no provider timeout
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
 PROVIDER_LABEL="${NW_PROVIDER_LABEL:-}"
@@ -858,6 +858,17 @@ while IFS=$'\t' read -r pr_number pr_branch pr_labels; do
     continue
   fi
 
+  if [ -n "${TARGET_PR}" ] && [ "${pr_number}" = "${TARGET_PR}" ] && [ -n "${NW_TARGET_LOCAL_CHECK_COMMAND:-}" ]; then
+    if [ "${local_ready_for_review_label_present}" -eq 1 ]; then
+      log "INFO: PR #${pr_number} (${pr_branch}) failed merge-gate local checks; removing stale ${READY_FOR_REVIEW_LABEL} label"
+      clear_ready_for_human_review_label "${pr_number}"
+    fi
+    log "INFO: PR #${pr_number} (${pr_branch}) failed merge-gate local checks; targeted repair required"
+    NEEDS_WORK=1
+    PRS_NEEDING_WORK="${PRS_NEEDING_WORK} #${pr_number}"
+    continue
+  fi
+
   if has_ready_for_human_review_marker "${all_comments}" "${current_head_sha}"; then
     SKIPPED_ALREADY_REVIEWED_CURRENT_HEAD=1
     log "INFO: PR #${pr_number} (${pr_branch}) is already marked ready for human review at head ${current_head_sha:0:12}; skipping repeat automated review"
@@ -1001,21 +1012,24 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
     worker_pr="${WORKER_PRS[$idx]}"
     worker_output="${WORKER_OUTPUTS[$idx]}"
 
-    # Guard: abort the wait loop when the global budget is exhausted
-    PARENT_ELAPSED=$(( $(date +%s) - SCRIPT_START_TIME ))
-    PARENT_REMAINING=$(( MAX_RUNTIME - PARENT_ELAPSED ))
-    if [ "${PARENT_REMAINING}" -le 0 ]; then
-      log "PARALLEL: global timeout exhausted — killing remaining workers"
-      for remaining_idx in $(seq "${idx}" $(( ${#WORKER_PIDS[@]} - 1 ))); do
-        kill "${WORKER_PIDS[$remaining_idx]}" 2>/dev/null || true
-      done
-      EXIT_CODE=124
-      break
-    fi
+    watchdog_pid=""
+    if is_runtime_limited "${MAX_RUNTIME}"; then
+      # Guard: abort the wait loop when the global budget is exhausted
+      PARENT_ELAPSED=$(( $(date +%s) - SCRIPT_START_TIME ))
+      PARENT_REMAINING=$(( MAX_RUNTIME - PARENT_ELAPSED ))
+      if [ "${PARENT_REMAINING}" -le 0 ]; then
+        log "PARALLEL: global timeout exhausted — killing remaining workers"
+        for remaining_idx in $(seq "${idx}" $(( ${#WORKER_PIDS[@]} - 1 ))); do
+          kill "${WORKER_PIDS[$remaining_idx]}" 2>/dev/null || true
+        done
+        EXIT_CODE=124
+        break
+      fi
 
-    # Watchdog: kill the worker if it outlives the remaining budget
-    ( sleep "${PARENT_REMAINING}" 2>/dev/null; kill "${worker_pid}" 2>/dev/null || true ) &
-    watchdog_pid=$!
+      # Watchdog: kill the worker if it outlives the remaining budget
+      ( sleep "${PARENT_REMAINING}" 2>/dev/null; kill "${worker_pid}" 2>/dev/null || true ) &
+      watchdog_pid=$!
+    fi
 
     worker_exit_code=0
     if wait "${worker_pid}" 2>/dev/null; then
@@ -1025,8 +1039,10 @@ if [ -z "${TARGET_PR}" ] && [ "${WORKER_MODE}" != "1" ] && [ "${PARALLEL_ENABLED
     fi
 
     # Cancel the watchdog — the worker finished in time
-    kill "${watchdog_pid}" 2>/dev/null || true
-    wait "${watchdog_pid}" 2>/dev/null || true
+    if [ -n "${watchdog_pid}" ]; then
+      kill "${watchdog_pid}" 2>/dev/null || true
+      wait "${watchdog_pid}" 2>/dev/null || true
+    fi
 
     if [ -f "${worker_output}" ] && [ -s "${worker_output}" ]; then
       cat "${worker_output}" >> "${LOG_FILE}"
@@ -1202,6 +1218,15 @@ if [ -n "${TARGET_PR}" ]; then
     TARGET_SCOPE_PROMPT+=$'- latest review score: not found\n'
     TARGET_SCOPE_PROMPT+=$'- action: review\n'
   fi
+  if [ -n "${NW_TARGET_LOCAL_CHECK_COMMAND:-}" ]; then
+    TARGET_SCOPE_PROMPT+=$'\n## Local Check Failure From Merge Gate\n'
+    TARGET_SCOPE_PROMPT+=$'- command: '"${NW_TARGET_LOCAL_CHECK_COMMAND}"$'\n'
+    TARGET_SCOPE_PROMPT+=$'- action: fix the PR so this local command passes before the PR can merge\n'
+    if [ -n "${NW_TARGET_LOCAL_CHECK_OUTPUT:-}" ]; then
+      TRUNCATED_LOCAL_CHECK_OUTPUT=$(printf '%s' "${NW_TARGET_LOCAL_CHECK_OUTPUT}" | head -c 10000)
+      TARGET_SCOPE_PROMPT+=$'\n### Local Check Output\n```text\n'"${TRUNCATED_LOCAL_CHECK_OUTPUT}"$'\n```\n'
+    fi
+  fi
 fi
 
 PRD_CONTEXT_PROMPT=""
@@ -1248,6 +1273,11 @@ if [ -n "${TARGET_PR}" ]; then
 fi
 
 remaining_runtime_budget() {
+  if ! is_runtime_limited "${MAX_RUNTIME}"; then
+    printf "0"
+    return 0
+  fi
+
   local now_ms
   local elapsed_ms
   local remaining_ms
@@ -1279,7 +1309,7 @@ sleep_with_runtime_budget() {
     return 0
   fi
 
-  if [ -z "${TARGET_PR}" ]; then
+  if [ -z "${TARGET_PR}" ] || ! is_runtime_limited "${MAX_RUNTIME}"; then
     sleep "${requested_sleep}"
     return 0
   fi
@@ -1305,7 +1335,7 @@ for ATTEMPT in $(seq 1 "${TOTAL_ATTEMPTS}"); do
   ATTEMPTS_MADE="${ATTEMPT}"
 
   ATTEMPT_TIMEOUT="${MAX_RUNTIME}"
-  if [ -n "${TARGET_PR}" ]; then
+  if [ -n "${TARGET_PR}" ] && is_runtime_limited "${MAX_RUNTIME}"; then
     # Give each targeted attempt the full remaining runtime budget.
     # Retries only happen after a quick return (low score / invalid output / rate limit);
     # a timed-out provider run is not retried, so pre-splitting the budget would
@@ -1347,7 +1377,7 @@ for ATTEMPT in $(seq 1 "${TOTAL_ATTEMPTS}"); do
   mapfile -d '' -t PROVIDER_CMD_PARTS < <(build_provider_cmd "${REVIEW_WORKTREE_DIR}" "${REVIEWER_PROMPT}")
 
   # Execute — always cd into worktree so provider tools resolve project files correctly
-  if (cd "${REVIEW_WORKTREE_DIR}" && timeout "${ATTEMPT_TIMEOUT}" "${PROVIDER_CMD_PARTS[@]}" 2>&1 | tee -a "${LOG_FILE}"); then
+  if (cd "${REVIEW_WORKTREE_DIR}" && run_with_optional_timeout "${ATTEMPT_TIMEOUT}" "${PROVIDER_CMD_PARTS[@]}" 2>&1 | tee -a "${LOG_FILE}"); then
     EXIT_CODE=0
   else
     EXIT_CODE=$?

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

@@ -7,7 +7,7 @@ set -euo pipefail
 # NOTE: This script expects environment variables to be set by the caller.
 # The Node.js CLI will inject config values via environment variables.
 # Required env vars (with defaults shown):
-#   NW_QA_MAX_RUNTIME=3600            - Maximum runtime in seconds (1 hour)
+#   NW_QA_MAX_RUNTIME=0               - Maximum runtime in seconds (0 = no timeout)
 #   NW_PROVIDER_CMD=claude            - AI provider CLI to use (claude, codex, etc.)
 #   NW_BRANCH_PATTERNS=feat/,night-watch/ - Comma-separated branch prefixes to match
 #   NW_QA_SKIP_LABEL=skip-qa          - Label to skip QA on a PR
@@ -19,7 +19,7 @@ PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/night-watch-qa.log"
-MAX_RUNTIME="${NW_QA_MAX_RUNTIME:-3600}"  # 1 hour
+MAX_RUNTIME="${NW_QA_MAX_RUNTIME:-0}"  # 0 = no provider timeout
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
 PROVIDER_LABEL="${NW_PROVIDER_LABEL:-}"
@@ -599,7 +599,7 @@ for pr_ref in ${PRS_NEEDING_QA}; do
   mapfile -d '' -t PROVIDER_CMD_PARTS < <(build_provider_cmd "${QA_WORKTREE_DIR}" "${QA_PROMPT}")
 
   # Execute — always cd into worktree so provider tools resolve project files correctly
-  if (cd "${QA_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" "${PROVIDER_CMD_PARTS[@]}" 2>&1 | tee -a "${LOG_FILE}"); then
+  if (cd "${QA_WORKTREE_DIR}" && run_with_optional_timeout "${MAX_RUNTIME}" "${PROVIDER_CMD_PARTS[@]}" 2>&1 | tee -a "${LOG_FILE}"); then
     PROVIDER_OK=1
   else
     local_exit=$?

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

@@ -10,7 +10,7 @@ set -euo pipefail
 # NOTE: This script expects environment variables to be set by the caller.
 # The Node.js CLI will inject config values via environment variables.
 # Required env vars (with defaults shown):
-#   NW_SLICER_MAX_RUNTIME=600  - Maximum runtime in seconds (10 minutes)
+#   NW_SLICER_MAX_RUNTIME=0    - Maximum runtime in seconds (0 = no timeout)
 #   NW_PROVIDER_CMD=claude     - AI provider CLI to use (claude, codex, etc.)
 #   NW_DRY_RUN=0               - Set to 1 for dry-run mode (prints diagnostics only)
 
@@ -19,7 +19,7 @@ PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/slicer.log"
 LOCK_FILE=""
-MAX_RUNTIME="${NW_SLICER_MAX_RUNTIME:-600}"  # 10 minutes
+MAX_RUNTIME="${NW_SLICER_MAX_RUNTIME:-0}"  # 0 = no timeout
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
 PROVIDER_LABEL="${NW_PROVIDER_LABEL:-}"
@@ -110,7 +110,7 @@ fi
 EXIT_CODE=0
 SLICER_RUN_START=$(date +%s)
 log "SLICER: Starting night-watch slice timeout=${MAX_RUNTIME}s"
-if timeout "${MAX_RUNTIME}" "${CLI_BIN}" slice >> "${LOG_FILE}" 2>&1; then
+if run_with_optional_timeout "${MAX_RUNTIME}" "${CLI_BIN}" slice >> "${LOG_FILE}" 2>&1; then
   EXIT_CODE=0
 else
   EXIT_CODE=$?