Silence ambiguous callers and scope transcript scan to this loop

Two blocking findings from the previous review:

  [P1] Round 7 dropped the `-n "$HOOK_SESSION_ID"` check from the
       cross-session guard to close its own P1. That inverted the
       failure mode: any wrapper call (e.g. rlcr-stop-gate.sh
       without --session-id) matched the guard forever once the
       marker was written, and the RLCR loop never resumed
       through the wrapper path.

  [P2] list_pending_background_task_ids scanned the entire
       session-wide Claude transcript. A long-running background
       Agent/Bash that started earlier in the same session --
       before the current RLCR loop was created -- counted as
       "pending" for this loop. The short-circuit fired forever
       for a loop that had no in-scope pending work of its own.

Fixes:

  * loop-codex-stop-hook.sh:
    - Add an "Ambiguous-Caller Marker Guard" before the cross-
      session guard. When bg-pending.marker is present AND
      HOOK_SESSION_ID is empty, exit 0 silently (no systemMessage,
      no on-disk mutation). The real Claude stop hook always has
      session_id populated and remains the only authoritative
      driver for parking and cleanup.
    - Restore `[[ -n "$HOOK_SESSION_ID" ]]` inside the cross-
      session guard. That branch now fires only when both session
      ids are non-empty and different.
    - Compute LOOP_START_TS via derive_loop_start_iso_ts once and
      pass it through every pending-tasks helper call.

  * loop-common.sh:
    - New derive_loop_start_iso_ts helper: parses the loop dir
      basename YYYY-MM-DD_HH-MM-SS and emits
      YYYY-MM-DDTHH:MM:SS.000Z for lexical comparison against
      transcript timestamps.
    - list_pending_background_task_ids gains an optional
      since_ts argument. Launch events are filtered by
      ($since_ts == "" or (.timestamp // "") == "" or
       (.timestamp // "") >= $since_ts). Empty since_ts
      preserves old scan-everything behavior; events without
      .timestamp remain included for fixture / older record
      compatibility.
    - has_pending_background_tasks and
      count_pending_background_tasks pass since_ts through
      unchanged.

Regressions in tests/test-stop-hook-bg-allow.sh:

  AC-10c refixtured to avoid the AC-10 marker leaking into the
         wrapper ambiguous-caller branch.
  AC-19  rewritten: empty HOOK_SESSION_ID + marker -> silent
         ALLOW, marker and state preserved (inverts Round 7's
         "parked" expectation).
  AC-21  helper filters a pre-loop launch and keeps an in-loop
         launch.
  AC-21b derive_loop_start_iso_ts produces the expected ISO-8601
         form.
  AC-21c end-to-end: pre-loop launch in transcript does not
         trigger the short-circuit; Codex runs.
  AC-22  wrapper without --session-id + no prior marker +
         pending bg -> writes marker, surfaces systemMessage.
  AC-22b wrapper without --session-id + prior marker -> silent
         ALLOW, marker and state preserved.

Validation:

  - bash tests/test-stop-hook-bg-allow.sh -> 37 passed, 0 failed
  - bash tests/run-all-tests.sh -> 1716 passed, 0 failed
  - HOME=/nonexistent/readonly bash tests/test-stop-hook-bg-allow.sh
    -> 37 passed, 0 failed

systemMessage wording unchanged on existing paths. Version stays
at 1.16.0.

Author: SihaoLiu

hooks/lib/loop-common.sh

@@ -267,6 +267,31 @@ extract_transcript_path() {
     expand_leading_tilde "$raw"
 }
 
+# Convert an RLCR loop dir basename to a lexically-comparable ISO-8601
+# timestamp suitable for filtering transcript events.
+#
+# The setup script creates loop dirs named `YYYY-MM-DD_HH-MM-SS`; real
+# Claude transcript events carry timestamps like `2026-04-16T13:19:26.819Z`.
+# String comparison works cleanly once we pad the loop boundary with
+# `.000Z` so sub-second transcript timestamps in the same second always
+# compare greater.
+#
+# Usage: derive_loop_start_iso_ts "$loop_dir"
+#   Prints the ISO-8601 timestamp, or empty string when the basename does
+#   not match the expected format.
+derive_loop_start_iso_ts() {
+    local loop_dir="$1"
+    local base
+    base=$(basename "$loop_dir" 2>/dev/null || echo "")
+    if [[ "$base" =~ ^([0-9]{4}-[0-9]{2}-[0-9]{2})_([0-9]{2})-([0-9]{2})-([0-9]{2})$ ]]; then
+        printf '%sT%s:%s:%s.000Z' \
+            "${BASH_REMATCH[1]}" \
+            "${BASH_REMATCH[2]}" \
+            "${BASH_REMATCH[3]}" \
+            "${BASH_REMATCH[4]}"
+    fi
+}
+
 # Enumerate background-task ids that have been launched but not yet marked
 # completed in a Claude Code transcript.jsonl.
 #
@@ -290,14 +315,23 @@ extract_transcript_path() {
 #
 # pending := launched \ completed
 #
-# Usage: list_pending_background_task_ids "$transcript_path"
+# Optional second argument `since_ts` (ISO-8601 string, e.g. the value
+# returned by `derive_loop_start_iso_ts`): when provided, only launch
+# events whose top-level `.timestamp` field is >= `since_ts` count as
+# candidate launches. Events without a `.timestamp` are included (keeps
+# fixture transcripts and older record formats working). This keeps
+# pre-loop session-wide background work from pinning an RLCR loop that
+# has no pending work of its own.
+#
+# Usage: list_pending_background_task_ids "$transcript_path" [since_ts]
 #   - Outputs one id per line on stdout (possibly empty).
 #   - Returns 0 when the transcript is readable (including when there are
 #     no pending tasks). Returns 1 when the transcript path is empty, not
 #     a regular file, or jq is unavailable, so callers must treat non-zero
 #     as "unknown -> do not short-circuit".
 list_pending_background_task_ids() {
     local transcript_path="$1"
+    local since_ts="${2:-}"
 
     # Normalize a leading tilde so direct callers (tests, ad-hoc scripts)
     # work correctly even when transcript_path was not routed through
@@ -312,8 +346,13 @@ list_pending_background_task_ids() {
     fi
 
     local launched completed
-    launched=$(jq -r '
+    launched=$(jq -r --arg since_ts "$since_ts" '
         select(.toolUseResult != null)
+        | select(
+            ($since_ts == ""
+             or ((.timestamp // "") == "")
+             or ((.timestamp // "") >= $since_ts))
+          )
         | select(
             (.toolUseResult.isAsync == true and (.toolUseResult.agentId // "") != "")
             or ((.toolUseResult.backgroundTaskId // "") != "")
@@ -355,22 +394,24 @@ list_pending_background_task_ids() {
 # Returns 1 when no pending tasks are detected (including fail-closed cases
 # like missing transcript, non-file path, or jq unavailable).
 #
-# Usage: has_pending_background_tasks "$transcript_path"
+# Usage: has_pending_background_tasks "$transcript_path" [since_ts]
 has_pending_background_tasks() {
     local transcript_path="$1"
+    local since_ts="${2:-}"
     local pending
-    pending=$(list_pending_background_task_ids "$transcript_path" 2>/dev/null) || return 1
+    pending=$(list_pending_background_task_ids "$transcript_path" "$since_ts" 2>/dev/null) || return 1
     [[ -n "$pending" ]]
 }
 
 # Prints the count of pending background tasks to stdout. Prints 0 for any
 # error case so callers can still format messages safely.
 #
-# Usage: count_pending_background_tasks "$transcript_path"
+# Usage: count_pending_background_tasks "$transcript_path" [since_ts]
 count_pending_background_tasks() {
     local transcript_path="$1"
+    local since_ts="${2:-}"
     local pending
-    pending=$(list_pending_background_task_ids "$transcript_path" 2>/dev/null) || {
+    pending=$(list_pending_background_task_ids "$transcript_path" "$since_ts" 2>/dev/null) || {
         echo 0
         return 0
     }

hooks/loop-codex-stop-hook.sh

@@ -68,6 +68,27 @@ if [[ -z "$LOOP_DIR" ]]; then
     exit 0
 fi
 
+# Shared state used by both guard blocks and the pending-tasks check below.
+# Loop-start boundary: derived from the loop dir basename (`YYYY-MM-DD_HH-MM-SS`).
+# Empty means derivation failed; helpers treat empty since_ts as no boundary.
+LOOP_START_TS=$(derive_loop_start_iso_ts "$LOOP_DIR")
+HOOK_TRANSCRIPT_PATH=$(extract_transcript_path "$HOOK_INPUT")
+
+# ========================================
+# Ambiguous-Caller Marker Guard
+# ========================================
+# If a bg-pending.marker is present but we have no session_id on this
+# hook invocation (typical of scripts/rlcr-stop-gate.sh invoked without
+# --session-id, or any other caller that doesn't forward session_id),
+# we cannot tell whether this caller owns the parked loop. Taking either
+# branch (foreign-session guard below, or same-session cleanup further
+# down) would be wrong in one of the two possible realities. Exit 0
+# silently: the real Claude hook will arrive with session_id populated
+# and drive parking / cleanup from an authoritative context.
+if [[ -f "$LOOP_DIR/bg-pending.marker" ]] && [[ -z "$HOOK_SESSION_ID" ]]; then
+    exit 0
+fi
+
 # ========================================
 # Cross-Session Parked-Loop Guard
 # ========================================
@@ -77,18 +98,17 @@ fi
 # transcript sees none of the foreign bg activity - so the only safe
 # response is to exit 0 with a distinct systemMessage and leave every
 # on-disk artifact (state file, stored session_id, marker) untouched.
-HOOK_TRANSCRIPT_PATH=$(extract_transcript_path "$HOOK_INPUT")
+#
+# Both sides of the session-id comparison must be non-empty for this
+# branch to trigger: an empty HOOK_SESSION_ID has already exited above
+# via the ambiguous-caller guard, and an empty stored session_id keeps
+# the backward-compat "matches any" semantics from find_active_loop.
 if [[ -f "$LOOP_DIR/bg-pending.marker" ]]; then
     GUARD_STATE_FILE=$(resolve_active_state_file "$LOOP_DIR")
     if [[ -n "$GUARD_STATE_FILE" ]]; then
         GUARD_STORED_SID=$(sed -n '/^---$/,/^---$/{ /^'"${FIELD_SESSION_ID}"':/{ s/^'"${FIELD_SESSION_ID}"': *//; p; } }' "$GUARD_STATE_FILE" 2>/dev/null | tr -d ' ')
-        # Non-empty stored session_id that differs from the caller's session
-        # (empty or not) means this is a foreign parked loop. Hook-input
-        # schemas that omit session_id -- such as rlcr-stop-gate.sh invoked
-        # without --session-id -- still get a mismatch here and take the
-        # safe exit path. An empty stored session_id keeps the existing
-        # backward-compat "matches any" semantics from find_active_loop.
         if [[ -n "$GUARD_STORED_SID" ]] \
+           && [[ -n "$HOOK_SESSION_ID" ]] \
            && [[ "$GUARD_STORED_SID" != "$HOOK_SESSION_ID" ]]; then
             jq -n \
                 '{systemMessage: "RLCR loop in this repo is parked by another Claude session waiting for background work. Stop allowed; your session leaves the loop untouched. If that session ended, run /humanize:cancel-rlcr-loop to clean up."}'
@@ -111,10 +131,14 @@ fi
 # untouched -- the next natural stop (after background work finishes) will
 # re-enter this hook with no pending tasks and run the normal flow.
 #
+# LOOP_START_TS confines the transcript scan to launches that actually
+# happened during this loop; earlier session-wide bg activity cannot pin
+# the loop.
+#
 # This check MUST run before any other gate (phase detection, state parsing,
 # branch / plan / git-clean / summary / max-iter checks, Codex review).
-if has_pending_background_tasks "$HOOK_TRANSCRIPT_PATH"; then
-    PENDING_BG_COUNT=$(count_pending_background_tasks "$HOOK_TRANSCRIPT_PATH")
+if has_pending_background_tasks "$HOOK_TRANSCRIPT_PATH" "$LOOP_START_TS"; then
+    PENDING_BG_COUNT=$(count_pending_background_tasks "$HOOK_TRANSCRIPT_PATH" "$LOOP_START_TS")
     # Mark the loop as parked; allows the same session to resume later and
     # makes the cross-session guard above reachable if the user opens a
     # different Claude session in this repo before the bg task completes.
@@ -142,7 +166,7 @@ fi
 # The check uses a single fresh call so we capture both the exit code
 # and the emptiness without double-running jq.
 if [[ -f "$LOOP_DIR/bg-pending.marker" ]]; then
-    if PENDING_BG_CHECK=$(list_pending_background_task_ids "$HOOK_TRANSCRIPT_PATH" 2>/dev/null) \
+    if PENDING_BG_CHECK=$(list_pending_background_task_ids "$HOOK_TRANSCRIPT_PATH" "$LOOP_START_TS" 2>/dev/null) \
        && [[ -z "$PENDING_BG_CHECK" ]]; then
         rm -f "$LOOP_DIR/bg-pending.marker" 2>/dev/null || true
     fi