@jonit-dev/night-watch-cli 1.5.1 → 1.5.3

package/scripts/night-watch-cron.sh

@@ -15,17 +15,17 @@ 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="/tmp/night-watch-${PROJECT_NAME}.lock"
+LOCK_FILE=""
 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=""
+ELIGIBLE_PRD=""
+CLAIMED=0
 
 # Ensure NVM / Node / Claude are on PATH
 export NVM_DIR="${HOME}/.nvm"
@@ -40,6 +40,8 @@ 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
@@ -53,7 +55,45 @@ if ! acquire_lock "${LOCK_FILE}"; then
   exit 0
 fi
 
-cleanup_worktrees "${PROJECT_DIR}"
+cleanup_on_exit() {
+  rm -f "${LOCK_FILE}"
+
+  if [ "${CLAIMED}" = "1" ] && [ -n "${ELIGIBLE_PRD}" ] && [ -n "${PRD_DIR}" ]; then
+    release_claim "${PRD_DIR}" "${ELIGIBLE_PRD}" || true
+  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}"
+else
+  PRD_DIR="${RUNTIME_PROJECT_DIR}/${PRD_DIR_REL}"
+fi
 
 ELIGIBLE_PRD=$(find_eligible_prd "${PRD_DIR}" "${MAX_RUNTIME}" "${PROJECT_DIR}")
 
@@ -64,29 +104,26 @@ fi
 
 # Claim the PRD to prevent other runs from selecting it
 claim_prd "${PRD_DIR}" "${ELIGIBLE_PRD}"
-
-# Update EXIT trap to also release claim
-trap "rm -f '${LOCK_FILE}'; release_claim '${PRD_DIR}' '${ELIGIBLE_PRD}'" EXIT
+CLAIMED=1
 
 PRD_NAME="${ELIGIBLE_PRD%.md}"
 BRANCH_NAME="night-watch/${PRD_NAME}"
-if [ -n "${NW_DEFAULT_BRANCH:-}" ]; then
-  DEFAULT_BRANCH="${NW_DEFAULT_BRANCH}"
-else
-  DEFAULT_BRANCH=$(detect_default_branch "${PROJECT_DIR}")
-fi
 
-log "START: Processing ${ELIGIBLE_PRD} on branch ${BRANCH_NAME}"
+log "START: Processing ${ELIGIBLE_PRD} on branch ${BRANCH_NAME} in runtime workspace ${RUNTIME_PROJECT_DIR}"
 
-cd "${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
+fi
 
 PROMPT="Implement the PRD at docs/PRDs/night-watch/${ELIGIBLE_PRD}
 
 ## Setup
-- Branch name MUST be exactly: ${BRANCH_NAME}
-- Create the branch from ${DEFAULT_BRANCH}: git checkout ${DEFAULT_BRANCH} && git pull origin ${DEFAULT_BRANCH} && git checkout -b ${BRANCH_NAME}
-- Use a git worktree: git worktree add ../${PROJECT_NAME}-nw-${PRD_NAME} ${BRANCH_NAME}
-- cd into the worktree, install dependencies
+- 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
 
 ## Implementation — PRD Executor Workflow
 Read .claude/commands/prd-executor.md and follow its FULL execution pipeline:
@@ -102,7 +139,6 @@ Follow all CLAUDE.md conventions (if present).
 - Commit all changes, push, and open a PR:
   git push -u origin ${BRANCH_NAME}
   gh pr create --title \"feat: <short title>\" --body \"<summary referencing PRD>\"
-- After PR is created, clean up: git worktree remove ../${PROJECT_NAME}-nw-${PRD_NAME}
 - Do NOT move the PRD to done/ — the cron script handles that
 - Do NOT process any other PRDs — only ${ELIGIBLE_PRD}"
 
@@ -115,6 +151,7 @@ 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 "Timeout:     ${MAX_RUNTIME}s"
   exit 0
 fi
@@ -135,21 +172,25 @@ while [ "${ATTEMPT}" -lt "${MAX_RETRIES}" ]; do
 
   case "${PROVIDER_CMD}" in
     claude)
-      if timeout "${MAX_RUNTIME}" \
-        claude -p "${PROMPT}" \
-          --dangerously-skip-permissions \
-          >> "${LOG_FILE}" 2>&1; then
+      if (
+        cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+          claude -p "${PROMPT}" \
+            --dangerously-skip-permissions \
+            >> "${LOG_FILE}" 2>&1
+      ); then
         EXIT_CODE=0
       else
         EXIT_CODE=$?
       fi
       ;;
     codex)
-      if timeout "${MAX_RUNTIME}" \
-        codex --quiet \
-          --yolo \
-          --prompt "${PROMPT}" \
-          >> "${LOG_FILE}" 2>&1; then
+      if (
+        cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+          codex --quiet \
+            --yolo \
+            --prompt "${PROMPT}" \
+            >> "${LOG_FILE}" 2>&1
+      ); then
         EXIT_CODE=0
       else
         EXIT_CODE=$?
@@ -185,16 +226,26 @@ while [ "${ATTEMPT}" -lt "${MAX_RETRIES}" ]; do
 done
 
 if [ ${EXIT_CODE} -eq 0 ]; then
-  PR_EXISTS=$(gh pr list --state open --json headRefName --jq '.[].headRefName' 2>/dev/null | grep -cF "${BRANCH_NAME}" || echo "0")
+  PR_EXISTS=$(cd "${RUNTIME_PROJECT_DIR}" && 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
+    fi
+
     mark_prd_done "${PRD_DIR}" "${ELIGIBLE_PRD}"
     night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" success --exit-code 0 2>/dev/null || true
-    git -C "${PROJECT_DIR}" add -A docs/PRDs/night-watch/
-    git -C "${PROJECT_DIR}" commit -m "chore: mark ${ELIGIBLE_PRD} as done (PR opened on ${BRANCH_NAME})
+    if [[ "${PRD_DIR_REL}" = /* ]]; then
+      log "WARN: PRD directory is absolute; skipping auto-commit of done/ move"
+    else
+      git -C "${RUNTIME_PROJECT_DIR}" add -A "${PRD_DIR_REL}/" || true
+      git -C "${RUNTIME_PROJECT_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 "${PROJECT_DIR}" push origin "${DEFAULT_BRANCH}" || true
+      git -C "${RUNTIME_PROJECT_DIR}" push origin "${DEFAULT_BRANCH}" || true
+    fi
     log "DONE: ${ELIGIBLE_PRD} implemented, PR opened, PRD moved to done/"
   else
     log "WARN: ${PROVIDER_CMD} exited 0 but no PR found on ${BRANCH_NAME} — PRD NOT moved to done"
@@ -202,9 +253,7 @@ Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>" || true
 elif [ ${EXIT_CODE} -eq 124 ]; then
   log "TIMEOUT: Night watch killed after ${MAX_RUNTIME}s while processing ${ELIGIBLE_PRD}"
   night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" timeout --exit-code 124 2>/dev/null || true
-  cleanup_worktrees "${PROJECT_DIR}"
 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
-  cleanup_worktrees "${PROJECT_DIR}"
 fi

package/scripts/night-watch-helpers.sh

@@ -292,17 +292,151 @@ 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 "${project_name}-nw" \
+    | grep "${marker}" \
     | 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() {
+  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}"
+    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}"
+    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"
+    return 0
+  fi
+
+  return 1
+}
+
+prepare_runtime_workspace() {
+  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 base_ref=""
+
+  git -C "${repo_dir}" fetch origin "${default_branch}" "${branch_name}" >> "${log_file}" 2>&1 || true
+
+  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
+    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
+    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
+}
+
+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
+
+  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 "${repo_dir}" checkout -B "${default_branch}" HEAD >> "${log_file}" 2>&1
+}
+
 # ── Mark PRD as done ─────────────────────────────────────────────────────────
 
 mark_prd_done() {

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

@@ -15,12 +15,14 @@ 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="/tmp/night-watch-pr-reviewer-${PROJECT_NAME}.lock"
+LOCK_FILE=""
 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"
@@ -34,6 +36,8 @@ 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
@@ -47,7 +51,37 @@ if ! acquire_lock "${LOCK_FILE}"; then
   exit 0
 fi
 
-cd "${PROJECT_DIR}"
+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}"
 
 # Convert comma-separated branch prefixes into a regex that matches branch starts.
 BRANCH_REGEX=""
@@ -122,38 +156,55 @@ fi
 
 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 "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")
+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 timeout "${MAX_RUNTIME}" \
-      claude -p "/night-watch-pr-reviewer" \
-        --dangerously-skip-permissions \
-        >> "${LOG_FILE}" 2>&1; then
+    if (
+      cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+        claude -p "${REVIEW_PROMPT}" \
+          --dangerously-skip-permissions \
+          >> "${LOG_FILE}" 2>&1
+    ); then
       EXIT_CODE=0
     else
       EXIT_CODE=$?
     fi
     ;;
   codex)
-    if timeout "${MAX_RUNTIME}" \
-      codex --quiet \
-        --yolo \
-        --prompt "$(cat "${PROJECT_DIR}/.claude/commands/night-watch-pr-reviewer.md")" \
-        >> "${LOG_FILE}" 2>&1; then
+    if (
+      cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+        codex --quiet \
+          --yolo \
+          --prompt "${REVIEW_PROMPT}" \
+          >> "${LOG_FILE}" 2>&1
+    ); then
       EXIT_CODE=0
     else
       EXIT_CODE=$?
@@ -165,8 +216,6 @@ 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,18 +67,18 @@ A PR needs attention if **either** the review score is below 80 **or** any CI jo
 
 4. **Fix the PR**:
 
-   a. **Check out the PR branch**:
+   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**:
       ```
       git fetch origin
       git checkout <branch-name>
       git pull origin <branch-name>
       ```
-
-   b. **Create a worktree** for the fixes:
-      ```
-      git worktree add ../${PROJECT_NAME}-nw-review-<branch-name> <branch-name>
-      ```
-      `cd` into worktree, run package install (npm install, yarn install, or pnpm install as appropriate).
+      Run package install (npm install, yarn install, or pnpm install as appropriate).
 
    c. **Address CI failures** (if any):
       - Read the failed job logs carefully to understand the root cause.
@@ -135,10 +135,6 @@ 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.

package/templates/night-watch.md

@@ -20,20 +20,13 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
 
    b. **Branch naming**: The branch MUST be named exactly `night-watch/<prd-filename-without-.md>`. Do NOT use `feat/`, `feature/`, or any other prefix. Example: for `health-check-endpoints.md` the branch is `night-watch/health-check-endpoints`.
 
-   c. **Create a feature branch** from ${DEFAULT_BRANCH}:
+   c. **Use the pre-provisioned runtime workspace**:
+      - You are already running in an isolated runtime workspace.
+      - The target branch `night-watch/<prd-filename-without-.md>` is already prepared.
+      - 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.
 
-   ```
-   git checkout ${DEFAULT_BRANCH} && git pull origin ${DEFAULT_BRANCH}
-   git checkout -b night-watch/<prd-filename-without-.md>
-   ```
-
-   d. **Create a git worktree** for isolated work:
-
-   ```
-   git worktree add ../${PROJECT_NAME}-nw-<prd-name> night-watch/<prd-name>
-   ```
-
-   Then `cd` into the worktree and run package install (npm install, yarn install, or pnpm install as appropriate).
+   d. Install dependencies in the current runtime workspace (npm install, yarn install, or pnpm install as appropriate).
 
    e. **Implement the PRD using the PRD Executor workflow**:
       - Read `.claude/commands/prd-executor.md` and follow its full execution pipeline.
@@ -64,11 +57,9 @@ 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. **Move PRD to done**:
 
    ```
-   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/
    ```
@@ -91,10 +82,8 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
 
    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.
+   m. **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 move the PRD to done. Log the failure in NIGHT-WATCH-SUMMARY.md with status "Failed" and the reason. The runtime controller handles cleanup. Then **stop** -- do not attempt the next PRD.
 
 Start now. Scan for available PRDs and process the first eligible one.