@jonit-dev/night-watch-cli 1.5.6 → 1.5.8

package/scripts/night-watch-cron.sh

@@ -15,18 +15,18 @@ set -euo pipefail
 PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 PRD_DIR_REL="${NW_PRD_DIR:-docs/PRDs/night-watch}"
+if [[ "${PRD_DIR_REL}" = /* ]]; then
+  PRD_DIR="${PRD_DIR_REL}"
+else
+  PRD_DIR="${PROJECT_DIR}/${PRD_DIR_REL}"
+fi
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/night-watch.log"
-LOCK_FILE=""
+# NOTE: Lock file path must match LOCK_FILE_PREFIX in src/constants.ts
+LOCK_FILE="/tmp/night-watch-${PROJECT_NAME}.lock"
 MAX_RUNTIME="${NW_MAX_RUNTIME:-7200}"  # 2 hours
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
-RUNTIME_MIRROR_DIR=""
-RUNTIME_PROJECT_DIR=""
-PRD_DIR=""
-ORIGINAL_PRD_DIR=""
-ELIGIBLE_PRD=""
-CLAIMED=0
 
 # Ensure NVM / Node / Claude are on PATH
 export NVM_DIR="${HOME}/.nvm"
@@ -41,8 +41,6 @@ mkdir -p "${LOG_DIR}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=night-watch-helpers.sh
 source "${SCRIPT_DIR}/night-watch-helpers.sh"
-PROJECT_RUNTIME_KEY=$(project_runtime_key "${PROJECT_DIR}")
-LOCK_FILE="/tmp/night-watch-${PROJECT_RUNTIME_KEY}.lock"
 
 # Validate provider
 if ! validate_provider "${PROVIDER_CMD}"; then
@@ -56,53 +54,7 @@ if ! acquire_lock "${LOCK_FILE}"; then
   exit 0
 fi
 
-cleanup_on_exit() {
-  rm -f "${LOCK_FILE}"
-
-  if [ "${CLAIMED}" = "1" ] && [ -n "${ELIGIBLE_PRD}" ] && [ -n "${PRD_DIR}" ]; then
-    release_claim "${PRD_DIR}" "${ELIGIBLE_PRD}" || true
-    if [ -n "${ORIGINAL_PRD_DIR}" ] && [ "${ORIGINAL_PRD_DIR}" != "${PRD_DIR}" ]; then
-      release_claim "${ORIGINAL_PRD_DIR}" "${ELIGIBLE_PRD}" || true
-    fi
-  fi
-
-  if [ -n "${RUNTIME_MIRROR_DIR}" ] && [ -n "${RUNTIME_PROJECT_DIR}" ]; then
-    cleanup_runtime_workspace "${RUNTIME_MIRROR_DIR}" "${RUNTIME_PROJECT_DIR}" || true
-  fi
-}
-
-trap cleanup_on_exit EXIT
-
-if [ -n "${NW_DEFAULT_BRANCH:-}" ]; then
-  DEFAULT_BRANCH="${NW_DEFAULT_BRANCH}"
-else
-  DEFAULT_BRANCH=$(detect_default_branch "${PROJECT_DIR}")
-fi
-
-runtime_info=()
-if mapfile -t runtime_info < <(prepare_runtime_workspace "${PROJECT_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"); then
-  RUNTIME_MIRROR_DIR="${runtime_info[0]:-}"
-  RUNTIME_PROJECT_DIR="${runtime_info[1]:-}"
-else
-  log "FAIL: Could not prepare runtime workspace for ${PROJECT_DIR}"
-  exit 1
-fi
-
-if [ -z "${RUNTIME_MIRROR_DIR}" ] || [ -z "${RUNTIME_PROJECT_DIR}" ]; then
-  log "FAIL: Runtime workspace paths are missing"
-  exit 1
-fi
-
-if [[ "${PRD_DIR_REL}" = /* ]]; then
-  PRD_DIR="${PRD_DIR_REL}"
-  ORIGINAL_PRD_DIR="${PRD_DIR_REL}"
-else
-  PRD_DIR="${RUNTIME_PROJECT_DIR}/${PRD_DIR_REL}"
-  ORIGINAL_PRD_DIR="${PROJECT_DIR}/${PRD_DIR_REL}"
-fi
-
-# Promote any pending-review PRDs whose PRs have been merged
-promote_merged_prds "${ORIGINAL_PRD_DIR}" "${PROJECT_DIR}" || true
+cleanup_worktrees "${PROJECT_DIR}"
 
 ELIGIBLE_PRD=$(find_eligible_prd "${PRD_DIR}" "${MAX_RUNTIME}" "${PROJECT_DIR}")
 
@@ -113,30 +65,35 @@ fi
 
 # Claim the PRD to prevent other runs from selecting it
 claim_prd "${PRD_DIR}" "${ELIGIBLE_PRD}"
-# Also mirror claim to original project dir so the status dashboard can see it
-if [ "${ORIGINAL_PRD_DIR}" != "${PRD_DIR}" ]; then
-  claim_prd "${ORIGINAL_PRD_DIR}" "${ELIGIBLE_PRD}" || true
-fi
-CLAIMED=1
+
+# Update EXIT trap to also release claim
+trap "rm -f '${LOCK_FILE}'; release_claim '${PRD_DIR}' '${ELIGIBLE_PRD}'" EXIT
 
 PRD_NAME="${ELIGIBLE_PRD%.md}"
 BRANCH_NAME="night-watch/${PRD_NAME}"
-
-log "START: Processing ${ELIGIBLE_PRD} on branch ${BRANCH_NAME} in runtime workspace ${RUNTIME_PROJECT_DIR}"
-
-if ! prepare_branch_checkout "${RUNTIME_PROJECT_DIR}" "${BRANCH_NAME}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
-  log "FAIL: Could not prepare branch ${BRANCH_NAME} in runtime workspace"
-  night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
-  exit 1
+WORKTREE_DIR="$(dirname "${PROJECT_DIR}")/${PROJECT_NAME}-nw-${PRD_NAME}"
+BOOKKEEP_WORKTREE_DIR="$(dirname "${PROJECT_DIR}")/${PROJECT_NAME}-nw-bookkeeping"
+if [ -n "${NW_DEFAULT_BRANCH:-}" ]; then
+  DEFAULT_BRANCH="${NW_DEFAULT_BRANCH}"
+else
+  DEFAULT_BRANCH=$(detect_default_branch "${PROJECT_DIR}")
+fi
+if [[ "${PRD_DIR_REL}" = /* ]]; then
+  BOOKKEEP_PRD_DIR="${PRD_DIR_REL}"
+else
+  BOOKKEEP_PRD_DIR="${BOOKKEEP_WORKTREE_DIR}/${PRD_DIR_REL}"
 fi
 
+log "START: Processing ${ELIGIBLE_PRD} on branch ${BRANCH_NAME} (worktree: ${WORKTREE_DIR})"
+
 PROMPT="Implement the PRD at docs/PRDs/night-watch/${ELIGIBLE_PRD}
 
 ## Setup
-- You are already inside an isolated runtime workspace: ${RUNTIME_PROJECT_DIR}
-- Current branch is already prepared: ${BRANCH_NAME}
-- Do not run git checkout/switch in ${PROJECT_DIR}
-- Do not create or remove worktrees; the runtime controller handles isolation and cleanup
+- You are already inside an isolated worktree at: ${WORKTREE_DIR}
+- Current branch is already checked out: ${BRANCH_NAME}
+- Do NOT run git checkout/switch in ${PROJECT_DIR}
+- Do NOT create or remove worktrees; the cron script manages that
+- 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:
@@ -164,11 +121,18 @@ if [ "${NW_DRY_RUN:-0}" = "1" ]; then
   echo "Provider:    ${PROVIDER_CMD}"
   echo "Eligible PRD: ${ELIGIBLE_PRD}"
   echo "Branch:      ${BRANCH_NAME}"
-  echo "Runtime Dir: ${RUNTIME_PROJECT_DIR}"
+  echo "Worktree:    ${WORKTREE_DIR}"
+  echo "Bookkeeping: ${BOOKKEEP_WORKTREE_DIR}"
   echo "Timeout:     ${MAX_RUNTIME}s"
   exit 0
 fi
 
+if ! prepare_branch_worktree "${PROJECT_DIR}" "${WORKTREE_DIR}" "${BRANCH_NAME}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
+  log "FAIL: Unable to create isolated worktree ${WORKTREE_DIR} for ${BRANCH_NAME}"
+  night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
+  exit 1
+fi
+
 # Sandbox: prevent the agent from modifying crontab during execution
 export NW_EXECUTION_CONTEXT=agent
 
@@ -186,7 +150,7 @@ while [ "${ATTEMPT}" -lt "${MAX_RETRIES}" ]; do
   case "${PROVIDER_CMD}" in
     claude)
       if (
-        cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+        cd "${WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
           claude -p "${PROMPT}" \
             --dangerously-skip-permissions \
             >> "${LOG_FILE}" 2>&1
@@ -198,7 +162,7 @@ while [ "${ATTEMPT}" -lt "${MAX_RETRIES}" ]; do
       ;;
     codex)
       if (
-        cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+        cd "${WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
           codex --quiet \
             --yolo \
             --prompt "${PROMPT}" \
@@ -239,20 +203,33 @@ while [ "${ATTEMPT}" -lt "${MAX_RETRIES}" ]; do
 done
 
 if [ ${EXIT_CODE} -eq 0 ]; then
-  PR_EXISTS=$(cd "${RUNTIME_PROJECT_DIR}" && gh pr list --state open --json headRefName --jq '.[].headRefName' 2>/dev/null | grep -cF "${BRANCH_NAME}" || echo "0")
+  PR_EXISTS=$(gh pr list --state open --json headRefName --jq '.[].headRefName' 2>/dev/null | grep -cF "${BRANCH_NAME}" || echo "0")
   if [ "${PR_EXISTS}" -gt 0 ]; then
     release_claim "${PRD_DIR}" "${ELIGIBLE_PRD}"
-    CLAIMED=0
-    if ! checkout_default_branch "${RUNTIME_PROJECT_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
-      log "WARN: Could not switch runtime workspace to ${DEFAULT_BRANCH}; PRD not moved to done/"
-      exit 0
+    # NOTE: PRDs are moved to done/ immediately when a PR is opened rather than waiting for
+    # the PR to merge. This is intentional — once a PR exists, the agent's implementation
+    # work is complete and it should not pick up this PRD again. Human review takes it from here.
+    if prepare_detached_worktree "${PROJECT_DIR}" "${BOOKKEEP_WORKTREE_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
+      if mark_prd_done "${BOOKKEEP_PRD_DIR}" "${ELIGIBLE_PRD}"; then
+        night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" success --exit-code 0 2>/dev/null || true
+        if [[ "${PRD_DIR_REL}" = /* ]]; then
+          git -C "${BOOKKEEP_WORKTREE_DIR}" add -A "${PRD_DIR_REL}" || true
+        else
+          git -C "${BOOKKEEP_WORKTREE_DIR}" add -A "${PRD_DIR_REL}/" || true
+        fi
+        git -C "${BOOKKEEP_WORKTREE_DIR}" commit -m "chore: mark ${ELIGIBLE_PRD} as done (PR opened on ${BRANCH_NAME})
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>" || true
+        git -C "${BOOKKEEP_WORKTREE_DIR}" push origin "HEAD:${DEFAULT_BRANCH}" || true
+        log "DONE: ${ELIGIBLE_PRD} implemented, PR opened, PRD moved to done/"
+      else
+        log "WARN: Failed to move ${ELIGIBLE_PRD} to done/ in bookkeeping worktree"
+      fi
+    else
+      log "WARN: Unable to prepare bookkeeping worktree for ${ELIGIBLE_PRD}"
     fi
-
-    mark_prd_pending_review "${ORIGINAL_PRD_DIR}" "${ELIGIBLE_PRD}" "${PROJECT_DIR}" "${BRANCH_NAME}"
-    night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" success --exit-code 0 2>/dev/null || true
-    log "PENDING-REVIEW: ${ELIGIBLE_PRD} implemented, PR opened, waiting for merge"
   else
-    log "WARN: ${PROVIDER_CMD} exited 0 but no PR found on ${BRANCH_NAME} — PRD NOT moved to pending-review"
+    log "WARN: ${PROVIDER_CMD} exited 0 but no PR found on ${BRANCH_NAME} — PRD NOT moved to done"
   fi
 elif [ ${EXIT_CODE} -eq 124 ]; then
   log "TIMEOUT: Night watch killed after ${MAX_RUNTIME}s while processing ${ELIGIBLE_PRD}"
@@ -261,3 +238,5 @@ else
   log "FAIL: Night watch exited with code ${EXIT_CODE} while processing ${ELIGIBLE_PRD}"
   night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code "${EXIT_CODE}" 2>/dev/null || true
 fi
+
+cleanup_worktrees "${PROJECT_DIR}"

package/scripts/night-watch-helpers.sh

@@ -292,149 +292,78 @@ cleanup_worktrees() {
   local project_dir="${1:?project_dir required}"
   local project_name
   project_name=$(basename "${project_dir}")
-  local marker="${2:-${project_name}-nw}"
 
   git -C "${project_dir}" worktree list --porcelain 2>/dev/null \
     | grep '^worktree ' \
     | awk '{print $2}' \
-    | grep "${marker}" \
+    | grep "${project_name}-nw" \
     | while read -r wt; do
         log "CLEANUP: Removing leftover worktree ${wt}"
         git -C "${project_dir}" worktree remove --force "${wt}" 2>/dev/null || true
       done || true
 }
 
-# ── Runtime workspace isolation ───────────────────────────────────────────────
-
-project_runtime_key() {
+# Pick the best available ref for creating a new detached worktree.
+resolve_worktree_base_ref() {
   local project_dir="${1:?project_dir required}"
-  local project_name
-  local hash
-  project_name=$(basename "${project_dir}")
-
-  if command -v sha1sum >/dev/null 2>&1; then
-    hash=$(printf "%s" "${project_dir}" | sha1sum | awk '{print $1}')
-  elif command -v shasum >/dev/null 2>&1; then
-    hash=$(printf "%s" "${project_dir}" | shasum | awk '{print $1}')
-  else
-    hash=$(printf "%s" "${project_dir}" | cksum | awk '{print $1}')
-  fi
-
-  printf "%s-%s" "${project_name}" "${hash:0:12}"
-}
-
-resolve_runtime_base_ref() {
-  local git_dir="${1:?git_dir required}"
   local default_branch="${2:?default_branch required}"
 
-  if git -C "${git_dir}" rev-parse --verify --quiet "refs/remotes/origin/${default_branch}" >/dev/null; then
-    printf "%s" "refs/remotes/origin/${default_branch}"
+  if git -C "${project_dir}" rev-parse --verify --quiet "refs/remotes/origin/${default_branch}" >/dev/null; then
+    printf "%s" "origin/${default_branch}"
     return 0
   fi
 
-  if git -C "${git_dir}" rev-parse --verify --quiet "refs/heads/${default_branch}" >/dev/null; then
-    printf "%s" "refs/heads/${default_branch}"
+  if git -C "${project_dir}" rev-parse --verify --quiet "refs/heads/${default_branch}" >/dev/null; then
+    printf "%s" "${default_branch}"
     return 0
   fi
 
-  if git -C "${git_dir}" rev-parse --verify --quiet "refs/remotes/origin/HEAD" >/dev/null; then
-    printf "%s" "refs/remotes/origin/HEAD"
+  if git -C "${project_dir}" rev-parse --verify --quiet "refs/remotes/origin/HEAD" >/dev/null; then
+    printf "%s" "origin/HEAD"
     return 0
   fi
 
   return 1
 }
 
-prepare_runtime_workspace() {
+# Create an isolated worktree on a branch without checking out that branch
+# in the user's current project directory.
+prepare_branch_worktree() {
   local project_dir="${1:?project_dir required}"
-  local default_branch="${2:?default_branch required}"
-  local log_file="${3:-${LOG_FILE:-/dev/null}}"
-  local runtime_root="${NW_RUNTIME_ROOT:-${HOME}/.night-watch/runtime}"
-  local runtime_key
-  local runtime_base
-  local mirror_dir
-  local runs_dir
-  local worktree_dir
-  local clone_source=""
-  local base_ref=""
-
-  runtime_key=$(project_runtime_key "${project_dir}")
-  runtime_base="${runtime_root}/${runtime_key}"
-  mirror_dir="${runtime_base}/mirror.git"
-  runs_dir="${runtime_base}/runs"
-  worktree_dir="${runs_dir}/run-$(date +%Y%m%d-%H%M%S)-$$"
-
-  mkdir -p "${runs_dir}"
-
-  if [ ! -d "${mirror_dir}" ]; then
-    clone_source=$(git -C "${project_dir}" config --get remote.origin.url 2>/dev/null || echo "")
-
-    if [ -n "${clone_source}" ]; then
-      if ! git clone --mirror "${clone_source}" "${mirror_dir}" >> "${log_file}" 2>&1; then
-        git clone --mirror "${project_dir}" "${mirror_dir}" >> "${log_file}" 2>&1
-      fi
-    else
-      git clone --mirror "${project_dir}" "${mirror_dir}" >> "${log_file}" 2>&1
-    fi
-  fi
-
-  git -C "${mirror_dir}" remote update --prune >> "${log_file}" 2>&1 || true
-
-  base_ref=$(resolve_runtime_base_ref "${mirror_dir}" "${default_branch}") || return 1
-  git -C "${mirror_dir}" worktree add --detach "${worktree_dir}" "${base_ref}" >> "${log_file}" 2>&1
-
-  printf "%s\n%s\n" "${mirror_dir}" "${worktree_dir}"
-}
-
-cleanup_runtime_workspace() {
-  local mirror_dir="${1:?mirror_dir required}"
   local worktree_dir="${2:?worktree_dir required}"
-
-  git -C "${mirror_dir}" worktree remove --force "${worktree_dir}" 2>/dev/null || true
-  git -C "${mirror_dir}" worktree prune 2>/dev/null || true
-}
-
-prepare_branch_checkout() {
-  local repo_dir="${1:?repo_dir required}"
-  local branch_name="${2:?branch_name required}"
-  local default_branch="${3:?default_branch required}"
-  local log_file="${4:-${LOG_FILE:-/dev/null}}"
+  local branch_name="${3:?branch_name required}"
+  local default_branch="${4:?default_branch required}"
+  local log_file="${5:-${LOG_FILE:-/dev/null}}"
   local base_ref=""
 
-  git -C "${repo_dir}" fetch origin "${default_branch}" "${branch_name}" >> "${log_file}" 2>&1 || true
+  git -C "${project_dir}" fetch origin "${default_branch}" >> "${log_file}" 2>&1 || true
+  base_ref=$(resolve_worktree_base_ref "${project_dir}" "${default_branch}") || return 1
 
-  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/heads/${branch_name}" >/dev/null; then
-    git -C "${repo_dir}" checkout "${branch_name}" >> "${log_file}" 2>&1
+  if git -C "${project_dir}" rev-parse --verify --quiet "refs/heads/${branch_name}" >/dev/null; then
+    git -C "${project_dir}" worktree add "${worktree_dir}" "${branch_name}" >> "${log_file}" 2>&1
     return $?
   fi
 
-  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/remotes/origin/${branch_name}" >/dev/null; then
-    git -C "${repo_dir}" checkout -b "${branch_name}" "origin/${branch_name}" >> "${log_file}" 2>&1
+  if git -C "${project_dir}" rev-parse --verify --quiet "refs/remotes/origin/${branch_name}" >/dev/null; then
+    git -C "${project_dir}" worktree add -b "${branch_name}" "${worktree_dir}" "origin/${branch_name}" >> "${log_file}" 2>&1
     return $?
   fi
 
-  base_ref=$(resolve_runtime_base_ref "${repo_dir}" "${default_branch}") || return 1
-  git -C "${repo_dir}" checkout -b "${branch_name}" "${base_ref}" >> "${log_file}" 2>&1
+  git -C "${project_dir}" worktree add -b "${branch_name}" "${worktree_dir}" "${base_ref}" >> "${log_file}" 2>&1
 }
 
-checkout_default_branch() {
-  local repo_dir="${1:?repo_dir required}"
-  local default_branch="${2:?default_branch required}"
-  local log_file="${3:-${LOG_FILE:-/dev/null}}"
-
-  git -C "${repo_dir}" fetch origin "${default_branch}" >> "${log_file}" 2>&1 || true
-
-  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/remotes/origin/${default_branch}" >/dev/null; then
-    git -C "${repo_dir}" checkout -B "${default_branch}" "origin/${default_branch}" >> "${log_file}" 2>&1
-    return $?
-  fi
+# Create an isolated detached worktree (useful for reviewer/controller flows).
+prepare_detached_worktree() {
+  local project_dir="${1:?project_dir required}"
+  local worktree_dir="${2:?worktree_dir required}"
+  local default_branch="${3:?default_branch required}"
+  local log_file="${4:-${LOG_FILE:-/dev/null}}"
+  local base_ref=""
 
-  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/heads/${default_branch}" >/dev/null; then
-    git -C "${repo_dir}" checkout "${default_branch}" >> "${log_file}" 2>&1
-    return $?
-  fi
+  git -C "${project_dir}" fetch origin "${default_branch}" >> "${log_file}" 2>&1 || true
+  base_ref=$(resolve_worktree_base_ref "${project_dir}" "${default_branch}") || return 1
 
-  git -C "${repo_dir}" checkout -B "${default_branch}" HEAD >> "${log_file}" 2>&1
+  git -C "${project_dir}" worktree add --detach "${worktree_dir}" "${base_ref}" >> "${log_file}" 2>&1
 }
 
 # ── Mark PRD as done ─────────────────────────────────────────────────────────
@@ -456,62 +385,6 @@ mark_prd_done() {
   fi
 }
 
-mark_prd_pending_review() {
-  local prd_dir="${1:?prd_dir required}"
-  local prd_file="${2:?prd_file required}"
-  local project_dir="${3:?project_dir required}"
-  local branch_name="${4:-}"
-  local prd_name="${prd_file%.md}"
-
-  local cli_bin
-  cli_bin=$(resolve_night_watch_cli) || {
-    log "WARN: Could not resolve night-watch CLI — skipping prd-state set"
-    return 1
-  }
-
-  "${cli_bin}" prd-state set "${project_dir}" "${prd_name}" --branch "${branch_name}" 2>/dev/null
-  log "PENDING-REVIEW: ${prd_file} marked as pending-review in prd-states.json"
-}
-
-# Check prd-states.json for pending-review PRDs and promote any whose PR has been merged to done/
-promote_merged_prds() {
-  local original_prd_dir="${1:?original_prd_dir required}"
-  local project_dir="${2:?project_dir required}"
-  local done_dir="${original_prd_dir}/done"
-
-  local cli_bin
-  cli_bin=$(resolve_night_watch_cli) || return 0
-
-  local pending_prds
-  pending_prds=$("${cli_bin}" prd-state list "${project_dir}" --status pending-review 2>/dev/null || echo "")
-  [ -z "${pending_prds}" ] && return 0
-
-  local merged_branches
-  merged_branches=$(cd "${project_dir}" && gh pr list --state merged --json headRefName --jq '.[].headRefName' 2>/dev/null || true)
-  [ -z "${merged_branches}" ] && return 0
-
-  while IFS= read -r prd_name; do
-    [ -z "${prd_name}" ] && continue
-    local prd_file="${prd_name}.md"
-    local branch_name="night-watch/${prd_name}"
-
-    if echo "${merged_branches}" | grep -qF "${branch_name}"; then
-      mkdir -p "${done_dir}"
-      if [ -f "${original_prd_dir}/${prd_file}" ]; then
-        mv "${original_prd_dir}/${prd_file}" "${done_dir}/${prd_file}"
-        "${cli_bin}" prd-state clear "${project_dir}" "${prd_name}" 2>/dev/null || true
-        log "MERGED: ${prd_name} PR was merged — moved to done/ and cleared from prd-states.json"
-      else
-        # File already gone (e.g. moved manually) — just clear the state
-        "${cli_bin}" prd-state clear "${project_dir}" "${prd_name}" 2>/dev/null || true
-        log "MERGED: ${prd_name} PR was merged — cleared from prd-states.json (file not found)"
-      fi
-    fi
-  done <<< "${pending_prds}"
-
-  return 0
-}
-
 # ── Rate limit detection ────────────────────────────────────────────────────
 
 # Check if the last N lines of the log contain a 429 rate limit error.

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

@@ -15,14 +15,13 @@ PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/night-watch-pr-reviewer.log"
-LOCK_FILE=""
+# NOTE: Lock file path must match LOCK_FILE_PREFIX in src/constants.ts (reviewer: prefix + "pr-reviewer-" + name)
+LOCK_FILE="/tmp/night-watch-pr-reviewer-${PROJECT_NAME}.lock"
 MAX_RUNTIME="${NW_REVIEWER_MAX_RUNTIME:-3600}"  # 1 hour
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
 MIN_REVIEW_SCORE="${NW_MIN_REVIEW_SCORE:-80}"
 BRANCH_PATTERNS_RAW="${NW_BRANCH_PATTERNS:-feat/,night-watch/}"
-RUNTIME_MIRROR_DIR=""
-RUNTIME_PROJECT_DIR=""
 
 # Ensure NVM / Node / Claude are on PATH
 export NVM_DIR="${HOME}/.nvm"
@@ -36,8 +35,6 @@ mkdir -p "${LOG_DIR}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=night-watch-helpers.sh
 source "${SCRIPT_DIR}/night-watch-helpers.sh"
-PROJECT_RUNTIME_KEY=$(project_runtime_key "${PROJECT_DIR}")
-LOCK_FILE="/tmp/night-watch-pr-reviewer-${PROJECT_RUNTIME_KEY}.lock"
 
 # Validate provider
 if ! validate_provider "${PROVIDER_CMD}"; then
@@ -51,37 +48,7 @@ if ! acquire_lock "${LOCK_FILE}"; then
   exit 0
 fi
 
-cleanup_on_exit() {
-  rm -f "${LOCK_FILE}"
-
-  if [ -n "${RUNTIME_MIRROR_DIR}" ] && [ -n "${RUNTIME_PROJECT_DIR}" ]; then
-    cleanup_runtime_workspace "${RUNTIME_MIRROR_DIR}" "${RUNTIME_PROJECT_DIR}" || true
-  fi
-}
-
-trap cleanup_on_exit EXIT
-
-if [ -n "${NW_DEFAULT_BRANCH:-}" ]; then
-  DEFAULT_BRANCH="${NW_DEFAULT_BRANCH}"
-else
-  DEFAULT_BRANCH=$(detect_default_branch "${PROJECT_DIR}")
-fi
-
-runtime_info=()
-if mapfile -t runtime_info < <(prepare_runtime_workspace "${PROJECT_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"); then
-  RUNTIME_MIRROR_DIR="${runtime_info[0]:-}"
-  RUNTIME_PROJECT_DIR="${runtime_info[1]:-}"
-else
-  log "FAIL: Could not prepare runtime workspace for reviewer"
-  exit 1
-fi
-
-if [ -z "${RUNTIME_MIRROR_DIR}" ] || [ -z "${RUNTIME_PROJECT_DIR}" ]; then
-  log "FAIL: Runtime workspace paths are missing for reviewer"
-  exit 1
-fi
-
-cd "${RUNTIME_PROJECT_DIR}"
+cd "${PROJECT_DIR}"
 
 # Convert comma-separated branch prefixes into a regex that matches branch starts.
 BRANCH_REGEX=""
@@ -154,41 +121,42 @@ if [ "${NEEDS_WORK}" -eq 0 ]; then
   exit 0
 fi
 
+if [ -n "${NW_DEFAULT_BRANCH:-}" ]; then
+  DEFAULT_BRANCH="${NW_DEFAULT_BRANCH}"
+else
+  DEFAULT_BRANCH=$(detect_default_branch "${PROJECT_DIR}")
+fi
+REVIEW_WORKTREE_DIR="$(dirname "${PROJECT_DIR}")/${PROJECT_NAME}-nw-review-runner"
+
 log "START: Found PR(s) needing work:${PRS_NEEDING_WORK}"
 
+cleanup_worktrees "${PROJECT_DIR}"
+
 # Dry-run mode: print diagnostics and exit
 if [ "${NW_DRY_RUN:-0}" = "1" ]; then
   echo "=== Dry Run: PR Reviewer ==="
   echo "Provider: ${PROVIDER_CMD}"
   echo "Branch Patterns: ${BRANCH_PATTERNS_RAW}"
   echo "Min Review Score: ${MIN_REVIEW_SCORE}"
-  echo "Default Branch: ${DEFAULT_BRANCH}"
-  echo "Runtime Dir: ${RUNTIME_PROJECT_DIR}"
   echo "Open PRs needing work:${PRS_NEEDING_WORK}"
+  echo "Default Branch: ${DEFAULT_BRANCH}"
+  echo "Review Worktree: ${REVIEW_WORKTREE_DIR}"
   echo "Timeout: ${MAX_RUNTIME}s"
   exit 0
 fi
 
-if [ -f "${RUNTIME_PROJECT_DIR}/.claude/commands/night-watch-pr-reviewer.md" ]; then
-  REVIEW_WORKFLOW=$(cat "${RUNTIME_PROJECT_DIR}/.claude/commands/night-watch-pr-reviewer.md")
-else
-  REVIEW_WORKFLOW=$(cat "${SCRIPT_DIR}/../templates/night-watch-pr-reviewer.md")
+if ! prepare_detached_worktree "${PROJECT_DIR}" "${REVIEW_WORKTREE_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
+  log "FAIL: Unable to create isolated reviewer worktree ${REVIEW_WORKTREE_DIR}"
+  exit 1
 fi
 
-REVIEW_PROMPT="You are running in an isolated runtime workspace at ${RUNTIME_PROJECT_DIR}.
-Do not run git checkout/switch in ${PROJECT_DIR}.
-Do not create or remove worktrees; the runtime controller handles that.
-Apply all fixes only inside the current runtime workspace.
-
-${REVIEW_WORKFLOW}"
-
 EXIT_CODE=0
 
 case "${PROVIDER_CMD}" in
   claude)
     if (
-      cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
-        claude -p "${REVIEW_PROMPT}" \
+      cd "${REVIEW_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
+        claude -p "/night-watch-pr-reviewer" \
           --dangerously-skip-permissions \
           >> "${LOG_FILE}" 2>&1
     ); then
@@ -199,10 +167,10 @@ case "${PROVIDER_CMD}" in
     ;;
   codex)
     if (
-      cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+      cd "${REVIEW_WORKTREE_DIR}" && timeout "${MAX_RUNTIME}" \
         codex --quiet \
           --yolo \
-          --prompt "${REVIEW_PROMPT}" \
+          --prompt "$(cat "${REVIEW_WORKTREE_DIR}/.claude/commands/night-watch-pr-reviewer.md")" \
           >> "${LOG_FILE}" 2>&1
     ); then
       EXIT_CODE=0
@@ -216,6 +184,8 @@ case "${PROVIDER_CMD}" in
     ;;
 esac
 
+cleanup_worktrees "${PROJECT_DIR}"
+
 if [ ${EXIT_CODE} -eq 0 ]; then
   log "DONE: PR reviewer completed successfully"
 elif [ ${EXIT_CODE} -eq 124 ]; then

package/templates/night-watch-pr-reviewer.md

@@ -67,14 +67,15 @@ A PR needs attention if **either** the review score is below 80 **or** any CI jo
 
 4. **Fix the PR**:
 
-   a. **Use the pre-provisioned runtime workspace**:
-      - You are already running in an isolated runtime workspace.
-      - Do **not** run `git checkout`/`git switch` in the original project directory.
-      - Do **not** create/remove worktrees manually; the runtime controller handles isolation and cleanup.
-
-   b. **Check out the PR branch inside the runtime workspace**:
+   a. **Create an isolated review worktree**:
       ```
       git fetch origin
+      git worktree add --detach ../${PROJECT_NAME}-nw-review-<branch-name> origin/${DEFAULT_BRANCH}
+      ```
+
+   b. **Check out the PR branch inside that worktree**:
+      ```
+      cd ../${PROJECT_NAME}-nw-review-<branch-name>
       git checkout <branch-name>
       git pull origin <branch-name>
       ```
@@ -135,6 +136,10 @@ A PR needs attention if **either** the review score is below 80 **or** any CI jo
       Night Watch PR Reviewer"
       ```
 
+   h. **Clean up worktree**: `git worktree remove ../${PROJECT_NAME}-nw-review-<branch-name>`
+
 5. **Repeat** for all open PRs that need work.
 
+6. When done, return to ${DEFAULT_BRANCH}: `git checkout ${DEFAULT_BRANCH}`
+
 Start now. Check for open PRs that need review feedback addressed or CI failures fixed.