forgedock 1.7.0 → 1.8.0

package/commands/orchestrate/phase-4-execution.md

@@ -189,6 +189,8 @@ should_dispatch() {
 
 **WHY THIS EXISTS** <!-- Added: forge#1912 -->: Phase 4's dispatch loops previously launched every DAG-ready issue in one shot — the engine-first bash loop backgrounded every `should_dispatch()`-passing issue with no count limit, and the Agent-spawn-fallback path was explicitly instructed to "launch all ready agents simultaneously." On a large ready set this saturates the Anthropic API rate limit in one burst, causing cascading failures across most of the batch. This is a distinct, count-denominated gate from the dollar-denominated `--budget` gate above (Step 4A-pre.0) — an issue can be deferred for budget reasons, concurrency reasons, or both; each gate accumulates its own deferred list independently.
 
+`MAX_CONCURRENT` caps top-level `/work-on` dispatches, not the total number of harness subagents. A normal worker can spawn context, architect, implement, validate, quality-gate, and review children. Budget **8 total subagent spawns per worker** when choosing this value: `max_concurrent <= session_subagent_budget / 8`. This is a conservative planning multiplier, not a second runtime semaphore; the harness does not expose a reliable cross-agent spawn counter to this shell-level dispatcher.
+
 Initialize the concurrency cap and its batch-scope tracking state before the first dispatch:
 
 ```bash
@@ -209,8 +211,12 @@ fi
 
 ACTIVE_DISPATCH_COUNT=0             # in-flight dispatched-but-not-yet-completed agents, this batch
 DEFERRED_CONCURRENCY_ISSUES=()      # ready issues held back because no headroom was available
+SUBAGENT_SPAWN_BUDGET_PER_WORKER=8  # /work-on + build/review fan-out planning estimate
+TOP_LEVEL_DISPATCH_TOTAL=0
+PLANNED_SUBAGENT_SPAWNS=0
+OBSERVED_SUBAGENT_SPAWNS="unavailable" # replace only with harness telemetry; never infer
 
-echo "Concurrency gate initialized: MAX_CONCURRENT=${MAX_CONCURRENT} (forge.yaml → orchestration.max_concurrent; default 12 when unset or invalid)"
+echo "Concurrency gate initialized: MAX_CONCURRENT=${MAX_CONCURRENT}; plan for up to $((MAX_CONCURRENT * SUBAGENT_SPAWN_BUDGET_PER_WORKER)) subagent spawns in flight (8 per worker)"
 # --- End concurrency gate initialization ---
 ```
 
@@ -226,6 +232,31 @@ dispatch_headroom() {
 
 **This is a hard cap, not a suggestion.** No dispatch site in Phase 4 may background/spawn more than `dispatch_headroom` new agents without first waiting for in-flight agents to complete. Issues that cannot be dispatched due to the cap go into `DEFERRED_CONCURRENCY_ISSUES[]` and are released — in the order they were deferred — as running agents complete (Step 4B), the same event-driven model (no sleep/poll loops) the file already uses for DAG-readiness and budget gating.
 
+**Dispatch accounting**: Immediately after each successful top-level dispatch, increment `TOP_LEVEL_DISPATCH_TOTAL` and add `SUBAGENT_SPAWN_BUDGET_PER_WORKER` to `PLANNED_SUBAGENT_SPAWNS`. When the runtime reports child-spawn telemetry, replace `OBSERVED_SUBAGENT_SPAWNS` with that measured total; otherwise leave it `unavailable` rather than fabricating a measured value.
+
+### Step 4A-pre.0.3: Secondary content-creation backpressure (MANDATORY)
+
+GitHub's `resources.core` quota does not report secondary content-creation throttles. Treat any GitHub API response with HTTP `403` whose body contains `secondary rate limit` as a batch-wide backpressure signal.
+
+```bash
+# Call from every dispatcher-owned gh write/create wrapper and from a child completion
+# report that includes its final GitHub API error. Do not retry the failed request here.
+SECONDARY_RATE_LIMITED=false
+SECONDARY_RATE_LIMIT_MESSAGE=""
+
+record_secondary_rate_limit() {
+  local STATUS="$1"
+  local BODY="$2"
+  if [ "$STATUS" = "403" ] && echo "$BODY" | grep -qi 'secondary rate limit'; then
+    SECONDARY_RATE_LIMITED=true
+    SECONDARY_RATE_LIMIT_MESSAGE="$BODY"
+    echo "SECONDARY RATE LIMIT: pausing all new dispatch. Do not retry GitHub content creation until an operator resumes the batch." >&2
+  fi
+}
+```
+
+Before every dispatch site computes headroom or launches a worker, check `SECONDARY_RATE_LIMITED`. When true, preserve the ready/deferred queues, launch no more workers, and end the active dispatch cycle. Do not poll or retry GitHub calls to discover recovery: an operator resumes the batch after the throttle clears. In-flight agents receive this contract in the dispatch prompt: on a secondary-limit 403, they must stop their GitHub write/create retry loop, report the response to the orchestrator, and exit their current phase without creating replacement work.
+
 ### Step 4A-pre: Staging baseline tracking (MANDATORY — continuous)
 
 **WHY THIS EXISTS**: Milestone-code-onto-staging contamination incidents (see issue #150) produce unexpected growth on the staging branch that is otherwise invisible until after a deploy. In the streaming DAG model, there are no discrete wave boundaries — instead, track a running baseline and check after each agent completion.
@@ -409,6 +440,16 @@ echo "Step 4A.pre: using BATCH_T0=${BATCH_T0} for Step 4C's run-spawned cascade
 DEFERRED_FINDINGS=()
 QUEUED_FINDINGS=()
 declare -A DEFERRED_REASONS
+# Count every finding regardless of admission, so a deferred refinement never
+# makes the reported amplification ratio look better than it was.
+FINDINGS_SPAWNED=0
+MERGED_UNITS=0
+AMPLIFICATION_RATIO_HISTORY=()
+AMPLIFICATION_DEFERRED=()
+declare -A FINDINGS_BY_SOURCE_PR
+declare -A REFINEMENT_FINDINGS
+declare -A NEW_SURFACE_FINDINGS
+declare -A AMPLIFICATION_FINDING_SEEN
 declare -A AGENT_ISSUE_MAP
 # Engine-first dispatch equivalent of AGENT_ISSUE_MAP (fixed forge#2466): keyed by issue
 # number, holds the task id returned by each backgrounded `Bash(run_in_background=true,
@@ -416,6 +457,29 @@ declare -A AGENT_ISSUE_MAP
 # this map to identify which issue a background-Bash completion notification belongs to,
 # the same role AGENT_ISSUE_MAP plays for Agent-tool `agent_completed` notifications.
 declare -A ENGINE_DISPATCH_MAP
+# OpenCode native task equivalent of ENGINE_DISPATCH_MAP. Keys are issue numbers;
+# values are the session ids returned by task(background=true). This is a live
+# cache only; every entry must also be persisted as a FORGE:DISPATCH comment.
+declare -A OPENCODE_DISPATCH_MAP
+
+# Reconstruct the live map after compaction/restart from the durable dispatch
+# records. The issue association is the map key; only the latest running record
+# is restored, because a later completed/error record has already released it.
+for NUM in "${ISSUES[@]}"; do
+  DISPATCH_BODY=$(gh api repos/{GH_REPO}/issues/"$NUM"/comments \
+    --jq '[.[] | select(.body | contains("FORGE:DISPATCH")) | .body] | last // ""' 2>/dev/null || true)
+  TASK_ID=$(printf '%s' "$DISPATCH_BODY" | jq -Rr 'try capture("\\\"runtime\\\":\\\"opencode\\\",\\\"child_session_id\\\":\\\"(?<id>[^\\\"]+)\\\".*\\\"state\\\":\\\"running\\\"").id catch ""')
+  if [ -n "$TASK_ID" ]; then
+    OPENCODE_DISPATCH_MAP["$NUM"]="$TASK_ID"
+  fi
+done
+
+# Full-repository intake is intentionally separate from Step 4C's T0-scoped
+# review-finding cascade. It is enabled only for an operator-authorised
+# policy: all run; records every open issue already observed so CI-created
+# actionable work is admitted once rather than rediscovered every cycle.
+declare -A SEEN_OPEN_ISSUES
+FULL_REPO_SWEEP_COUNT=0
 
 # Same-file current-state brief forwarding (forge#1860). Populated by the core streaming
 # dispatch loop below (Step 4B) whenever a Layer 1/2/3 structural predecessor edge (see
@@ -425,6 +489,42 @@ declare -A ENGINE_DISPATCH_MAP
 declare -A SAME_FILE_BRIEF
 declare -A EDGE_BRIEFED
 
+# DONE-path edge re-verification memo (forge#2848). A conclusive re-derivation is
+# memoized in EDGE_REDERIVED; inconclusive results get one retry, capped by
+# EDGE_REDERIVE_ATTEMPTS. This avoids caching a transient failure while bounding
+# extraction to two attempts per descendant per batch.
+declare -A EDGE_REDERIVED
+declare -A EDGE_REDERIVE_ATTEMPTS
+
+# Affected-file extraction helper, resolved for the DONE-path cohort re-derivation
+# (forge#2848). Same resolver precedence as phase-3-dependency.md Step 3C Layer 1 —
+# ForgeDock's runtime installation before the target repository — because the
+# orchestrator runs inside the project being worked on, where a bare
+# `bash scripts/extract-affected-files.sh` silently fails when that project has not
+# copied ForgeDock's helper scripts into its own repository (#2794/#2791).
+resolve_extract_affected_files() {
+  local candidates=()
+  [ -n "${FORGE_HOME:-}" ] && candidates+=("$FORGE_HOME/scripts/extract-affected-files.sh")
+  [ -n "${REPO_PATH:-}" ] && candidates+=("$REPO_PATH/scripts/extract-affected-files.sh")
+  candidates+=("$PWD/scripts/extract-affected-files.sh")
+
+  local candidate
+  for candidate in "${candidates[@]}"; do
+    if [ -f "$candidate" ]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+  done
+  echo "ERROR: extract-affected-files.sh is not installed in any configured runtime path." >&2
+  return 1
+}
+
+# Non-fatal here, unlike Phase 3's hard exit: Phase 3 cannot build a DAG at all without
+# this helper, whereas Phase 4 only needs it for the OPTIONAL re-derivation optimization.
+# If it is missing, re-derivation is skipped and edges stay as planned — the conservative
+# direction, and identical to this file's pre-forge#2848 behavior.
+AFFECTED_FILES_SCRIPT=$(resolve_extract_affected_files) || AFFECTED_FILES_SCRIPT=""
+
 # Human-gated idle/backpressure flag (Step 4B item 6.7, forge#1814). Starts false —
 # recomputed every completion cycle over {all_batch_issue_numbers}. Declared at batch
 # scope (not per-agent) so Step 4C can read the latest value on every iteration.
@@ -449,15 +549,15 @@ CASCADE_POLICY_NAME=$(yq '.orchestration.cascade.policy // "balanced"' forge.yam
 
 case "$CASCADE_POLICY_NAME" in
   all)
-    PRESET_MAX_GEN="unlimited"; PRESET_TOKEN_BUDGET="unlimited"; PRESET_DEFER_GATED="false"; PRESET_KEYWORD="false"; PRESET_P3_SAME_FILE="false" ;;
+    PRESET_MAX_GEN="unlimited"; PRESET_BATCH_MAX_GEN=2; PRESET_TOKEN_BUDGET="unlimited"; PRESET_DEFER_GATED="false"; PRESET_KEYWORD="false"; PRESET_P3_SAME_FILE="false" ;;
   conservative)
-    PRESET_MAX_GEN=1; PRESET_TOKEN_BUDGET=450000; PRESET_DEFER_GATED="true"; PRESET_KEYWORD="true"; PRESET_P3_SAME_FILE="true" ;;
+    PRESET_MAX_GEN=1; PRESET_BATCH_MAX_GEN=2; PRESET_TOKEN_BUDGET=450000; PRESET_DEFER_GATED="true"; PRESET_KEYWORD="true"; PRESET_P3_SAME_FILE="true" ;;
   balanced)
-    PRESET_MAX_GEN=1; PRESET_TOKEN_BUDGET=900000; PRESET_DEFER_GATED="true"; PRESET_KEYWORD="true"; PRESET_P3_SAME_FILE="true" ;;
+    PRESET_MAX_GEN=1; PRESET_BATCH_MAX_GEN=2; PRESET_TOKEN_BUDGET=900000; PRESET_DEFER_GATED="true"; PRESET_KEYWORD="true"; PRESET_P3_SAME_FILE="true" ;;
   *)
     echo "WARNING: forge.yaml → orchestration.cascade.policy \"${CASCADE_POLICY_NAME}\" is not one of: all, balanced, conservative — falling back to \"balanced\""
     CASCADE_POLICY_NAME="balanced"
-    PRESET_MAX_GEN=1; PRESET_TOKEN_BUDGET=900000; PRESET_DEFER_GATED="true"; PRESET_KEYWORD="true"; PRESET_P3_SAME_FILE="true" ;;
+    PRESET_MAX_GEN=1; PRESET_BATCH_MAX_GEN=2; PRESET_TOKEN_BUDGET=900000; PRESET_DEFER_GATED="true"; PRESET_KEYWORD="true"; PRESET_P3_SAME_FILE="true" ;;
 esac
 
 # max_generation is authoritatively resolved in phase-1-resolve.md (it only governs
@@ -470,6 +570,14 @@ if [ "$MAX_GENERATION_FOR_NOTICE" != "unlimited" ] && ! echo "$MAX_GENERATION_FO
   MAX_GENERATION_FOR_NOTICE="$PRESET_MAX_GEN"
 fi
 
+# P3 batching is a distinct, bounded aggregation exception to autonomous cascade
+# admission. Unlike max_generation, it must always be finite, including policy: all.
+BATCH_MAX_GENERATION=$(yq ".orchestration.cascade.batch_max_generation // ${PRESET_BATCH_MAX_GEN}" forge.yaml 2>/dev/null || echo "$PRESET_BATCH_MAX_GEN")
+if ! echo "$BATCH_MAX_GENERATION" | grep -qE '^[1-9][0-9]*$'; then
+  echo "WARNING: forge.yaml → orchestration.cascade.batch_max_generation is not a positive integer (\"${BATCH_MAX_GENERATION}\") — falling back to default ${PRESET_BATCH_MAX_GEN}"
+  BATCH_MAX_GENERATION="$PRESET_BATCH_MAX_GEN"
+fi
+
 # token_budget precedence: orchestration.cascade.token_budget (new home) >
 # pipeline.token_budget_per_batch (deprecated alias, forge#1858, kept working
 # unchanged) > the resolved preset default. Accepts the "unlimited" sentinel —
@@ -488,13 +596,30 @@ fi
 
 TOKEN_ESTIMATE_PER_FINDING=$(yq '.pipeline.token_estimate_per_finding // 150000' forge.yaml 2>/dev/null || echo 150000)
 
+# Amplification is observational by default. The optional ceiling is evaluated
+# only against same-lineage refinements in Step 4C, never against new surface.
+CASCADE_MAX_AMPLIFICATION=$(yq '.orchestration.cascade.max_amplification // "off"' forge.yaml 2>/dev/null || echo "off")
+if [ "$CASCADE_MAX_AMPLIFICATION" != "off" ]; then
+  if ! echo "$CASCADE_MAX_AMPLIFICATION" | grep -qE '^[0-9]+(\.[0-9]+)?$' || \
+     ! awk "BEGIN { exit !($CASCADE_MAX_AMPLIFICATION > 0) }"; then
+    echo "WARNING: forge.yaml → orchestration.cascade.max_amplification must be a positive number or off — disabling the bound"
+    CASCADE_MAX_AMPLIFICATION="off"
+  fi
+fi
+CONVERGENCE_WINDOW=$(yq '.orchestration.cascade.convergence_window // 3' forge.yaml 2>/dev/null || echo 3)
+if ! echo "$CONVERGENCE_WINDOW" | grep -qE '^[1-9][0-9]*$'; then
+  echo "WARNING: forge.yaml → orchestration.cascade.convergence_window must be a positive integer — falling back to 3"
+  CONVERGENCE_WINDOW=3
+fi
+echo "Cascade amplification: max_amplification=${CASCADE_MAX_AMPLIFICATION} convergence_window=${CONVERGENCE_WINDOW} (off preserves current admission behavior)"
+
 # Independent boolean levers — each accepts an explicit granular override on
 # top of the resolved preset (preset supplies the default, not a hard value).
 CASCADE_DEFER_ON_BATCH_GATED=$(yq ".orchestration.cascade.defer_on_batch_gated // ${PRESET_DEFER_GATED}" forge.yaml 2>/dev/null || echo "$PRESET_DEFER_GATED")
 CASCADE_KEYWORD_HEURISTIC=$(yq ".orchestration.cascade.keyword_heuristic // ${PRESET_KEYWORD}" forge.yaml 2>/dev/null || echo "$PRESET_KEYWORD")
 CASCADE_P3_SAME_FILE_DEFER=$(yq ".orchestration.cascade.p3_same_file_defer // ${PRESET_P3_SAME_FILE}" forge.yaml 2>/dev/null || echo "$PRESET_P3_SAME_FILE")
 
-echo "Cascade admission policy resolved: policy=${CASCADE_POLICY_NAME} token_budget=${TOKEN_BUDGET} defer_on_batch_gated=${CASCADE_DEFER_ON_BATCH_GATED} keyword_heuristic=${CASCADE_KEYWORD_HEURISTIC} p3_same_file_defer=${CASCADE_P3_SAME_FILE_DEFER} (forge.yaml → orchestration.cascade; see docs/CONFIG.md)"
+echo "Cascade admission policy resolved: policy=${CASCADE_POLICY_NAME} token_budget=${TOKEN_BUDGET} batch_max_generation=${BATCH_MAX_GENERATION} defer_on_batch_gated=${CASCADE_DEFER_ON_BATCH_GATED} keyword_heuristic=${CASCADE_KEYWORD_HEURISTIC} p3_same_file_defer=${CASCADE_P3_SAME_FILE_DEFER} (forge.yaml → orchestration.cascade; see docs/CONFIG.md)"
 
 # Both-uncapped notice (loud, one-time, printed once per orchestrate invocation since
 # this resolution block itself runs once at Step 4A.pre) — never a preset default except
@@ -521,6 +646,8 @@ TOKEN_DEFERRED=()   # findings deferred by the token-budget rule this run (re-ev
 # alone. <!-- Added: forge#1909 -->
 SURFACE_BATCHED_FINDINGS=()   # all member issue numbers absorbed into a batch across the run
 SURFACE_BATCH_COUNT=0         # count of batch issues created across the run
+BATCHABLE_DEFERRED_P3=()      # gen-2+ P3s eligible only for bounded P3 aggregation (forge#2849)
+declare -A FINDING_GENERATIONS
 
 for NUM in {ready_issue_numbers}; do
   PR_BASE=$(bash "$CLASSIFY_LANE_SCRIPT" "$NUM" -R {GH_REPO}) || {
@@ -544,6 +671,97 @@ Use `${ISSUE_LANE[$NUM]}` and `${ISSUE_PR_BASE[$NUM]}` to populate `{LANE}` and
 
 ### Step 4A: Dispatch ready issues
 
+### Step 4A.0: Probe Knowledge Gist capability once
+
+Probe the authenticated identity once for this orchestration run before any engine, Agent, or
+OpenCode worker is dispatched. A GitHub App installation token identifies as `Bot` and cannot use
+the Gists API; cache that fact rather than letting every worker rediscover it by attempting a
+write. An unavailable identity probe preserves existing behavior for PAT-authenticated runs.
+
+```bash
+if [ -z "${FORGE_GIST_CAPABLE+x}" ]; then
+  GIST_AUTH_TYPE=$(gh api user --jq '.type' 2>/dev/null || true)
+  if [ "$GIST_AUTH_TYPE" = "Bot" ]; then
+    FORGE_GIST_CAPABLE=false
+  else
+    FORGE_GIST_CAPABLE=true
+  fi
+  export FORGE_GIST_CAPABLE
+fi
+
+if [ "$FORGE_GIST_CAPABLE" = "true" ]; then
+  echo "Knowledge Gist capability available"
+else
+  echo "INFO: Knowledge Gist subsystem unavailable for this authentication; workers will skip it"
+fi
+```
+
+Carry `FORGE_GIST_CAPABLE` unchanged through every dispatch path. Do not probe it in individual
+workers dispatched by this run. Phase 6 reports a false value once at batch level.
+
+**Claims-board dispatch gate (MANDATORY, before every individual dispatch)** <!-- Added: forge#2844 -->: The coordination issue is the durable authority for file ownership. Do not use `EDGE_FILES`, `ISSUE_FILES`, or a remembered prior read as evidence that a claim is free. Immediately before dispatching each issue, re-read the full claims board and refuse that dispatch when the issue's declared file set intersects a live claim held by another issue. This applies equally to engine, Claude Agent, and OpenCode task dispatches, including newly-ready issues and wake reconstruction.
+
+```bash
+# Returns unreleased claims as [{holder: "123", files: "..."}]. A release is a separate,
+# later comment, so it must be paired with its claim by holder rather than searched for in the
+# claim comment itself. Terminal holder states also self-heal claims left behind by dead agents.
+read_active_claims() {
+  local COORD_NUM="$1"
+  local CLAIMS HOLDER TERMINAL
+  CLAIMS=$(gh api --paginate --slurp "repos/{GH_REPO}/issues/${COORD_NUM}/comments" 2>/dev/null \
+    | jq -c '
+        flatten as $comments |
+        [$comments[]
+         | select(.body | contains("<!-- FORGE:CLAIM -->"))
+         | . as $claim
+         | ($claim.body | capture("\\*\\*Holder\\*\\*: #(?<holder>[0-9]+)").holder) as $holder
+         | select([$comments[]
+                   | select(.body | contains("<!-- FORGE:CLAIM_RELEASED -->"))
+                   | select((.body | capture("\\*\\*Holder\\*\\*: #(?<holder>[0-9]+)").holder) == $holder)
+                   | select(.created_at > $claim.created_at)] | length == 0)
+         | {holder: $holder,
+            files: ($claim.body | capture("\\*\\*Files\\*\\*: (?<files>[\\s\\S]*?)(?:\\n\\*\\*Interfaces\\*\\*:|$)").files)}]') || return 1
+
+  for HOLDER in $(echo "$CLAIMS" | jq -r '.[].holder'); do
+    TERMINAL=$(gh issue view "$HOLDER" -R {GH_REPO} --json labels --jq \
+      '[.labels[].name | select(. == "workflow:merged" or . == "workflow:invalid" or . == "workflow:awaiting-merge" or . == "needs-human")] | length > 0' 2>/dev/null)
+    [ "$TERMINAL" = "true" ] && CLAIMS=$(echo "$CLAIMS" | jq --arg holder "$HOLDER" '[.[] | select(.holder != $holder)]')
+  done
+  echo "$CLAIMS"
+}
+
+claim_conflicts_with_live_holder() {
+  local NUM="$1" TARGET_FILES CLAIM HOLDER CLAIM_FILES OVERLAP
+  TARGET_FILES=$(printf '%s\n' "${ISSUE_FILES[$NUM]:-}" | sed -E '/^[[:space:]]*$/d; s/^[[:space:]]*[-*][[:space:]]*//; s/`//g' | sort -u)
+  [ -z "$TARGET_FILES" ] && return 1  # No declared paths: normal conservative DAG rules still apply.
+
+  ACTIVE_CLAIMS=$(read_active_claims "$COORD_ISSUE_NUMBER") || {
+    echo "REFUSING TO DISPATCH #${NUM}: could not read the durable claims board." >&2
+    return 0
+  }
+  while IFS= read -r CLAIM; do
+    HOLDER=$(echo "$CLAIM" | jq -r '.holder')
+    [ "$HOLDER" = "$NUM" ] && continue
+    CLAIM_FILES=$(echo "$CLAIM" | jq -r '.files' | sed -E '/^[[:space:]]*$/d; s/^[[:space:]]*[-*][[:space:]]*//; s/`//g' | sort -u)
+    OVERLAP=$(comm -12 <(printf '%s\n' "$TARGET_FILES") <(printf '%s\n' "$CLAIM_FILES"))
+    if [ -n "$OVERLAP" ]; then
+      echo "DEFERRING #${NUM}: declared files overlap live claim held by #${HOLDER}: ${OVERLAP//$'\n'/, }"
+      return 0
+    fi
+  done < <(echo "$ACTIVE_CLAIMS" | jq -c '.[]')
+  return 1
+}
+
+# Run this immediately before each engine Bash, Agent(), or OpenCode task call. Do not batch the
+# board read: another worker can claim a file between two dispatches in the same ready set.
+if [ -n "${FORGE_COORD_ISSUE:-}" ] && [ -n "${COORD_ISSUE_NUMBER:-}" ]; then
+  if claim_conflicts_with_live_holder "$NUM"; then
+    DEFERRED_CLAIM_ISSUES+=("$NUM")
+    continue
+  fi
+fi
+```
+
 **Engine-first dispatch (default)**: When `forgedock` is in PATH, dispatch each ready issue via the durable engine rather than spawning prose Agent sub-agents. The engine's phase table enforces gate semantics in code — its fail-closed review gate and deterministic phase ordering are not subject to LLM interpretation.
 
 **OpenCode dispatch (runtime-neutral adapter)**: When `FORGE_RUNTIME=opencode` or
@@ -556,10 +774,45 @@ and continue until it reaches
 `workflow:merged`, `workflow:invalid`, `needs-human`, or
 `workflow:awaiting-merge`.
 
+The native call is asynchronous and must be issued once per issue in
+`DISPATCH_NOW`, in the same assistant message where the batch is dispatched:
+
+```
+task(
+  description="Work on {PROJECT_PREFIX}#{NUMBER}",
+  subagent_type="general",
+  background=true,
+  prompt="Use the same Phase 4A work-on template below. Before invoking it, run `export FORGE_GIST_CAPABLE={FORGE_GIST_CAPABLE}` so the cached orchestration capability is preserved. Invoke Skill(skill='work-on', args='{PROJECT_PREFIX}{NUMBER} --under-orchestration') and continue until a terminal workflow state."
+)
+```
+
+Capture the returned `<task id="..." state="running">` id in
+`OPENCODE_DISPATCH_MAP[{NUMBER}]` and immediately persist it to the issue:
+
+```bash
+ATTEMPT=$(gh api repos/{GH_REPO}/issues/{NUMBER}/comments \
+  --jq '[.[] | select(.body | contains("FORGE:DISPATCH") and contains("\"state\":\"running\""))] | length + 1')
+if [ "${DRY_RUN:-false}" = "false" ]; then
+  gh issue comment {NUMBER} {GH_FLAG} --body "<!-- FORGE:DISPATCH -->
+\`\`\`json
+{\"runtime\":\"opencode\",\"child_session_id\":\"{TASK_ID}\",\"attempt\":${ATTEMPT},\"state\":\"running\",\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}
+\`\`\`"
+fi
+```
+
+`background=true` is required for streaming DAG behavior; a foreground task
+makes the orchestrator wait for that issue and reintroduces a wave barrier. The ForgeDock OpenCode plugin opts into
+`OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` by default. An explicit
+`OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=false` is a supported degraded mode,
+but it must be reported as non-streaming rather than treated as equivalent to
+Claude background dispatch. Do not wait for the slowest sibling before handling
+an earlier task-result event.
+
 ```bash
 if [ "${FORGE_RUNTIME:-}" = "opencode" ]; then
   echo "OpenCode native task dispatch selected — load commands/work-on.md for each ready issue."
   echo "Do not call forgedock run-issue or the Claude Agent(...) fallback in this branch."
+  echo "Use task(subagent_type=general, background=true) once per ready issue and process each task-result event immediately."
   echo "If native task dispatch cannot run, post FORGE:OPENCODE_BLOCKED with the missing capability and add needs-human."
 fi
 ```
@@ -567,6 +820,13 @@ fi
 This branch is additive. When OpenCode is not selected, continue through the
 existing engine-first and Claude Agent-spawn paths below without modification.
 
+The generated OpenCode plugin is an executable boundary, not just prompt
+guidance: its `tool.execute.before` hook rejects `claude`, `forgedock
+run-issue`, `npx forgedock run-issue`, and recursive `opencode run` shell
+commands with `FORGE_OPENCODE_CAPABILITY_ERROR`. If a native Skill or Task is
+unavailable, stop with that bounded error and preserve the GitHub label state;
+never compensate by starting a second controller or the Claude-backed engine.
+
 **CRITICAL — never background via shell `&`/`wait`** (fixed forge#2466): A single `forgedock run-issue` invocation drives an issue through investigate → build → review → close and routinely runs 30+ minutes. Backgrounding the process at the *shell* level (`cmd &` … `wait`) does not escape the Bash tool's own per-invocation ceiling — `wait` is itself the foreground command the tool watches, and it blocks for the combined duration of every process in the chunk. This made engine-first dispatch effectively dead code: any chunk running longer than the ceiling was always killed, so every run silently fell through to the Agent-spawn fallback below. The fix: dispatch each `forgedock run-issue` invocation as its **own `Bash` tool call with `run_in_background=true`** — the harness's native "start it, don't wait, notify me on completion" primitive — never with shell-level `&`/`wait`. This is exactly the same async model the Agent-spawn-fallback path already uses (and Step 4B's notification-driven completion loop already expects), so one monitoring loop now covers both dispatch styles.
 
 ```bash
@@ -634,6 +894,18 @@ if [ "$FORGEDOCK_AVAILABLE" = "true" ]; then
   if [ "${#DEFERRED_CONCURRENCY_ISSUES[@]}" -gt 0 ]; then
     echo "CONCURRENCY DEFER: ${#DEFERRED_CONCURRENCY_ISSUES[@]} ready issue(s) held back — ${ACTIVE_DISPATCH_COUNT}/${MAX_CONCURRENT} already in flight. Will dispatch as slots free up: ${DEFERRED_CONCURRENCY_ISSUES[*]}"
   fi
+  # Filter against the durable board once while forming this engine batch. The tool-call
+  # instruction below re-checks immediately before each launch to close the remaining TOCTOU gap.
+  CLAIM_SAFE_DISPATCH=()
+  for NUM in "${DISPATCH_NOW[@]}"; do
+    if [ -n "${FORGE_COORD_ISSUE:-}" ] && [ -n "${COORD_ISSUE_NUMBER:-}" ] && claim_conflicts_with_live_holder "$NUM"; then
+      DEFERRED_CLAIM_ISSUES+=("$NUM")
+      continue
+    fi
+    CLAIM_SAFE_DISPATCH+=("$NUM")
+  done
+  DISPATCH_NOW=("${CLAIM_SAFE_DISPATCH[@]}")
+
   echo "Dispatching ${#DISPATCH_NOW[@]} issue(s) this message via forgedock run-issue (headroom was ${HEADROOM})"
 
   for NUM in "${DISPATCH_NOW[@]}"; do
@@ -670,10 +942,10 @@ fi
 fi
 ```
 
-**Dispatch each issue in `DISPATCH_NOW` via its own backgrounded `Bash` call (MANDATORY when `FORGEDOCK_AVAILABLE=true`) — never shell `&`/`wait`.** Issue one `Bash(...)` call per issue in `DISPATCH_NOW`, all in the same message, so they run concurrently within the headroom already computed above:
+**Dispatch each issue in `DISPATCH_NOW` via its own backgrounded `Bash` call (MANDATORY when `FORGEDOCK_AVAILABLE=true`) — never shell `&`/`wait`.** Immediately before each call, run `claim_conflicts_with_live_holder "{NUM}"`; if it returns success, defer that issue rather than dispatching it. Issue one `Bash(...)` call per remaining issue in `DISPATCH_NOW`, all in the same message, so they run concurrently within the headroom already computed above:
 
 ```
-Bash(command="forgedock run-issue {NUM} --lane {PR_BASE}", run_in_background=true, description="Engine-drive issue #{NUM}")
+Bash(command="FORGE_GIST_CAPABLE=${FORGE_GIST_CAPABLE} forgedock run-issue {NUM} --lane {PR_BASE}", run_in_background=true, description="Engine-drive issue #{NUM}")
 ```
 
 Capture the task id each call returns into `ENGINE_DISPATCH_MAP[{NUM}]` (declared alongside `AGENT_ISSUE_MAP` below — Step 4B's completion handler uses this map to identify which issue a backgrounded engine-mode `Bash` completion notification belongs to, the same role `AGENT_ISSUE_MAP` plays for `agent_completed` notifications):
@@ -687,7 +959,16 @@ ENGINE_DISPATCH_MAP[{NUM}] = <task_id returned by Bash(run_in_background=true, .
 
 If `DISPATCH_NOW` is empty (headroom is 0), do not dispatch any issues this cycle — wait for the next completion notification, exactly like the Agent-spawn path.
 
-**Agent-spawn path (fallback when forgedock CLI unavailable)**: When `FORGEDOCK_AVAILABLE=false`, spawn Agent sub-agents per issue using the template below. This preserves engine state via the SubagentStop hook even without the CLI.
+**Agent-spawn path (Claude fallback when forgedock CLI unavailable)**: When `FORGEDOCK_AVAILABLE=false` and the runtime is not OpenCode, spawn Agent sub-agents per issue using the template below. This preserves engine state via the SubagentStop hook even without the CLI.
+
+When the runtime is OpenCode, skip this Claude-only `Agent(...)` path entirely.
+Use the native `task` call above for initial and newly-ready issue dispatches.
+Translate only those OpenCode orchestration dispatches to `task(...)` with
+`subagent_type="general"` and `background=true`. Review and remediation are
+load-bearing child operations and must run foreground. Do not claim task-id
+resume support: after a restart, reconcile the latest `FORGE:DISPATCH` record
+with durable GitHub workflow state, then dispatch a fresh work-on continuation
+only when the issue is still non-terminal.
 
 **REMINDER: You MUST use the template below verbatim when on the Agent-spawn fallback path. Only fill in `{VARIABLES}`. Do NOT rewrite the agent prompt. Do NOT write custom implementation instructions. The agent MUST invoke `/work-on` via the Skill tool — this is the HARD RULE from the top of this file.**
 
@@ -709,6 +990,8 @@ Agent(
 **Repository**: {GH_REPO}
 **Repo path**: {REPO_PATH}
 
+**KNOWLEDGE GIST CAPABILITY**: This orchestration already probed it: `{FORGE_GIST_CAPABLE}`. Before invoking `/work-on`, run `export FORGE_GIST_CAPABLE={FORGE_GIST_CAPABLE}`. Do not re-probe or attempt Gist creation when it is `false`.
+
 **YOUR MISSION**: Invoke `/work-on` via the Skill tool and let it run to completion. `/work-on` is a self-contained routing loop that handles the ENTIRE pipeline: investigate → build (context → architect → implement → validate) → review (push → PR → /review-pr --auto-merge) → close (project board → trajectory log → worktree cleanup). Do NOT intervene, compensate, or manually close issues — `/work-on` handles everything including issue closure and label updates in its close phase.
 
 **CRITICAL — DO NOT STOP EARLY**: /work-on runs as a multi-phase routing loop. Each phase (investigate, build, review, close) returns an intermediate result — these are NOT completion signals. You are NOT done until the issue reaches a terminal state: `workflow:merged`, `workflow:invalid`, `needs-human`, or `workflow:awaiting-merge`. If /work-on returns after only one phase (e.g., investigation), you MUST invoke it again immediately — it will re-read GitHub state and continue to the next phase. Keep invoking /work-on until it reaches a terminal state. Never output 'done' or stop after an intermediate result.
@@ -721,7 +1004,9 @@ Agent(
   - For satellite repo issues: `Skill(skill='work-on', args='{SATELLITE_PREFIX}:{NUMBER} --under-orchestration')` (prefix from forge.yaml → repos.satellites)
   - The `--under-orchestration` flag tells `/work-on` to post its phase-entry `FORGE:HEARTBEAT` comments (Phases 0/1/3/5) — this orchestrator's Step 4B.5 stall detector depends on those timestamps. A solo `/work-on` run omits the flag and skips those writes entirely (see `commands/work-on.md` → Orchestration Flag).
 - NEVER bypass /work-on with manual git/gh commands — the label updates and structured comments are critical for tracking
-- **Temp files — ALWAYS use `mktemp`, NEVER a fixed path**: You are one of several agents running concurrently on this host and you share its `/tmp` with all of them. Any time you stage content in a temp file before passing it to `gh` (e.g. `--body-file`), create that path with `mktemp` (e.g. `BODY_FILE="$(mktemp)"`) — never a fixed literal like `/tmp/body.md` or `/tmp/issue.json`. A fixed path collides with another concurrently-running agent and can silently overwrite the content you staged (or you can silently overwrite theirs) before either of you reads it back — this has caused real cross-agent GitHub issue-body corruption. `mktemp` costs nothing and eliminates the collision. (forge#2198)
+- **File-backed GitHub bodies — entity scope plus read-back is mandatory**: Never stage a `gh --body-file` body at a generic shared `/tmp` path, including one made by bare `mktemp`, and never hand-roll a root-level path such as `/tmp_invbody_31076.txt`, which can hang unattended cleanup. Prefer the session scratchpad or a repo-relative scratch directory on Windows: a native Windows `gh` may not resolve Git Bash `/tmp` reliably. Create a filename that contains the target issue/PR number and an agent-unique token, then use `mktemp` for its random suffix. Put one caller-chosen marker such as `<!-- FORGE:BODY-INTEGRITY:${NUMBER}_investigator_${AGENT_TOKEN} -->` in the body. After every `gh issue create|edit` or `gh pr create|comment` using `--body-file`, re-read the target object and assert the exact marker is present; a mismatch is a hard error. Unique names reduce collisions, but only read-back detects a collision that substitutes plausible-looking content from another agent. Do not rely on eyeballing. (forge#2843, forge#2855) <!-- allowlist:check-command-side-effects -->
+- **GitHub secondary rate limit**: If a GitHub API call returns HTTP 403 with `secondary rate limit` in its response, do NOT retry it or start a polling loop. Stop GitHub content creation for this phase, report the status and response body to the orchestrator in your final result, and wait for a later batch resume. Retrying extends the throttle for every sibling.
+- **Temp files — ALWAYS use `mktemp`, NEVER hand-roll a path**: You are one of several agents running concurrently on this host and you share its `/tmp` with all of them. Any time you stage content in a temp file before passing it to `gh` (e.g. `--body-file`), create that path with `mktemp` (e.g. `BODY_FILE="$(mktemp)"`). Never write a temp file to a single-segment root path such as `/tmp_invbody_31076.txt`: Claude Code treats removing it as dangerous and requires an explicit approval that bypass mode cannot clear, hanging unattended runs. Also never use a fixed literal such as `/tmp/body.md` or `/tmp/issue.json`: a fixed path collides with another concurrently-running agent and can silently overwrite the content you staged (or you can silently overwrite theirs) before either of you reads it back. Safe: `BODY_FILE="$(mktemp)"`. Unsafe: `/tmp_invbody_31076.txt` (a missing slash that creates a root-level path) and `/tmp/body.md` (a fixed path). `mktemp` costs nothing and prevents both failures. (forge#2198, forge#2855)
 - **`docker cp` — NEVER write into a bind-mounted shared container**: If the project you're working on runs its dev/test containers with a bind mount to the main (non-worktree) checkout, `docker cp` into that container writes through the mount into the main checkout — not your isolated per-issue worktree. Before running `docker cp` into any container, confirm its mount source is your own worktree, not a shared/main one; if you can't confirm that, don't assume an in-container test run reflects your feature branch. (forge#2198)
 - NEVER target `main` for PRs targeting the default repo. Use `{STAGING_BRANCH}` for fast-lane issues, or `milestone/{slug}` for milestone issues.
 - Satellite repos (MCP, n8n) have no staging branch — fast-lane PRs go to `main` for those.
@@ -911,15 +1196,28 @@ fi
 echo "Dispatching ${#DISPATCH_NOW[@]} issue(s) this message (headroom was ${HEADROOM})"
 ```
 
-Spawn `Agent()` for every issue in `DISPATCH_NOW` (not the raw ready set) using the template above. After the batch spawn, increment `ACTIVE_DISPATCH_COUNT` by `${#DISPATCH_NOW[@]}` — this happens in addition to, not instead of, capturing each returned agent ID into `AGENT_ISSUE_MAP` above.
+Immediately before every Claude `Agent()` or OpenCode `task()` call, run `claim_conflicts_with_live_holder "{NUM}"`; when it returns success, append the issue to `DEFERRED_CLAIM_ISSUES[]` and do not make that call. Spawn `Agent()` for every remaining issue in `DISPATCH_NOW` (not the raw ready set) using the template above. After the batch spawn, increment `ACTIVE_DISPATCH_COUNT` by the number actually dispatched — this happens in addition to, not instead of, capturing each returned agent ID into `AGENT_ISSUE_MAP` above.
 
 If `DISPATCH_NOW` is empty (headroom is 0), do not spawn any agents this cycle — wait for the next `agent_completed` notification, which frees a slot and re-triggers this dispatch computation (Step 4B).
 
 ### Step 4B: Monitor completions and dispatch newly ready issues
 
-You will be automatically notified when each background agent completes — or, for an engine-first dispatch (Step 4A, `FORGEDOCK_AVAILABLE=true`), when a backgrounded `Bash(run_in_background=true, command="forgedock run-issue ...")` call completes. Both are the same underlying "background task finished" notification the harness delivers; treat them identically for the purposes of this step. **Do NOT use `sleep` loops to poll for completion.** Instead, wait for the automatic notification. When one arrives, look up which issue it belongs to — `AGENT_ISSUE_MAP` for an `agent_completed` notification, `ENGINE_DISPATCH_MAP` (fixed forge#2466) for a background-Bash notification from the engine-first path — and immediately process it exactly the same way regardless of which map resolved it; every check below (`classify_predecessor_state()`, dependent dispatch, stall/staging checks) keys off GitHub labels/state, not which dispatch mechanism produced them. **Fallback**: if a runtime ever fails to deliver a background-Bash completion notification, poll `gh issue view --json labels` for the in-flight engine-dispatched issue's workflow label instead of blocking — the same degrade-gracefully behavior already used when `BACKGROUND_DISPATCH_ENABLED=false` for the Agent-spawn path (see `phase-3-dependency.md` → Background Dispatch Mode).
+You will be automatically notified when each background agent completes — or, for an engine-first dispatch (Step 4A, `FORGEDOCK_AVAILABLE=true`), when a backgrounded `Bash(run_in_background=true, command="forgedock run-issue ...")` call completes. In OpenCode, a native background `task` first returns a `state="running"` result and later injects a synthetic `<task id="..." state="completed">` or `state="error"` result into this same parent session. The later result is the completion event; the initial running result is not completion. Both Claude notifications and OpenCode task-result events must trigger the same per-issue handling immediately. **Do NOT use `sleep` loops, wait for the slowest sibling, or poll before processing an event.** When one arrives, look up which issue it belongs to — `AGENT_ISSUE_MAP` for a Claude `agent_completed` notification, `ENGINE_DISPATCH_MAP` for a background-Bash notification, or `OPENCODE_DISPATCH_MAP` for an OpenCode task result — and immediately process it exactly the same way regardless of which map resolved it; every check below (`classify_predecessor_state()`, dependent dispatch, stall/staging checks) keys off GitHub labels/state, not which dispatch mechanism produced them. For an OpenCode completion, append this terminal record before releasing capacity:
+
+```bash
+if [ "${DRY_RUN:-false}" = "false" ]; then
+  gh issue comment {NUMBER} {GH_FLAG} --body "<!-- FORGE:DISPATCH -->
+\`\`\`json
+{\"runtime\":\"opencode\",\"child_session_id\":\"{TASK_ID}\",\"attempt\":${ATTEMPT},\"state\":\"{completed|error}\",\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}
+\`\`\`"
+fi
+```
+
+**Fallback**: if a runtime ever fails to deliver a background completion notification, read the latest `FORGE:DISPATCH` record and use the documented label-state recovery path, but do not convert the normal OpenCode path to foreground tasks or a wave barrier.
+
+For an OpenCode completion, retain `OPENCODE_DISPATCH_MAP[{NUMBER}]` until the terminal `FORGE:DISPATCH` record above has been posted successfully. Then remove that map entry and release capacity. This makes a restart deterministic: a latest `running` record restores the task-to-issue association, while a latest `completed` or `error` record cannot release the same slot twice.
 
-**Concurrency slot release (MANDATORY — first action on every completion)** <!-- Added: forge#1912 -->: The instant a completion notification arrives — `agent_completed`, or a background-Bash completion for an engine-dispatched issue — decrement `ACTIVE_DISPATCH_COUNT` by 1 — a worker slot has just freed, regardless of what terminal state the issue ended up in. Do this before any stall-recovery/resume logic below. If that agent is then resumed or fallback-dispatched (item 2 below, or Step 4B.5's stall recovery) because it stalled mid-pipeline rather than truly finishing, re-increment `ACTIVE_DISPATCH_COUNT` when the `Agent(resume=...)` (or, per item 2b below, the fresh `Agent(...)` fallback dispatch) call is issued — either re-occupies a worker slot exactly like a fresh dispatch does. (Step 4B.5's TIME-BASED hang detector — an agent that never completes at all, as opposed to one that completes at `workflow:engine-error` — remains `Agent(resume=...)`-specific and out of scope for this fix: an engine-dispatched issue that silently hangs still surfaces only via the standard stall-detection alert, and `forgedock resume-stalled` remains available as a separate manual/scripted recovery path for that case. The completion-triggered case — an engine-dispatched issue that DOES complete, at `workflow:engine-error` with empty committed state — is now auto-fallen-back to Agent-spawn by item 2b below, fixed forge#2743.)
+**Concurrency slot release (MANDATORY — first action on every completion)** <!-- Added: forge#1912 -->: The instant a completion notification arrives — `agent_completed`, a background-Bash completion, or an OpenCode `task` result with `state="completed"`/`state="error"` — decrement `ACTIVE_DISPATCH_COUNT` by 1 — a worker slot has just freed, regardless of what terminal state the issue ended up in. Do this before any stall-recovery/resume logic below. If that agent is then resumed or fallback-dispatched (item 2 below, or Step 4B.5's stall recovery) because it stalled mid-pipeline rather than truly finishing, re-increment `ACTIVE_DISPATCH_COUNT` when the `Agent(resume=...)` or a fresh OpenCode `task(background=true)` continuation is issued — either re-occupies a worker slot exactly like a fresh dispatch does. (Step 4B.5's TIME-BASED hang detector — an agent that never completes at all, as opposed to one that completes at `workflow:engine-error` — remains resume-specific and out of scope for this fix: an engine-dispatched issue that silently hangs still surfaces only via the standard stall-detection alert, and `forgedock resume-stalled` remains available as a separate manual/scripted recovery path for that case. The completion-triggered case — an engine-dispatched issue that DOES complete at `workflow:engine-error` with empty committed state — is still auto-fallen-back by item 2b below, fixed forge#2743.)
 
 **Ordering requirement (MANDATORY — prevents transient over-cap)**: For every agent that completed in this notification batch, finish its terminal-state check and, if applicable, its resume re-increment (items 1-2 below) BEFORE computing `dispatch_headroom` for item 5's newly-ready-issue dispatch. Computing headroom before a to-be-resumed agent's re-increment would let a genuinely-still-running agent's freed slot be double-booked — once by a fresh dispatch, once by the resume itself — transiently exceeding `MAX_CONCURRENT`. Process every completed agent's items 1-2 to a decision (terminal vs. resumed) first; only then compute headroom once for the batch's item 5 dispatch.
 
@@ -980,7 +1278,7 @@ classify_predecessor_state() {
 
 A GATED predecessor whose PR later merges reclassifies to DONE the next time `classify_predecessor_state` runs (its label flips to `workflow:merged`) — this is exactly what the merge-triggered wake check (item 6.6 below) relies on.
 
-**File-overlap edge re-verification** <!-- Added: forge#1904 --> — `classify_predecessor_state()` answers "is the predecessor resolved enough to proceed," but it says nothing about whether a specific Layer 1/2/3 file-overlap edge (`EDGE_KIND`/`EDGE_FILES`, tagged in `phase-3-dependency.md` Step 3C/3D) was ever real. Both were built from a **pre-build guess** — the predecessor's `FORGE:INVESTIGATOR` "Affected Files" list, or a raw issue-body parse if no investigation existed yet. Once a predecessor reaches FAILED or GATED, that guess must be checked against ground truth (the predecessor's actual PR diff, or the absence of any PR) before the edge is allowed to keep blocking a dependent. Without this, a predecessor that reaches `needs-human` or `workflow:invalid` having never touched the guessed shared file (or never opened a PR at all) leaves its dependents gated/skipped on a conflict that never existed.
+**File-overlap edge re-verification** <!-- Added: forge#1904 --> — `classify_predecessor_state()` answers "is the predecessor resolved enough to proceed," but it says nothing about whether a specific Layer 1/2/3 file-overlap edge (`EDGE_KIND`/`EDGE_FILES`, tagged in `phase-3-dependency.md` Step 3C/3D) was ever real. Both were built from a **pre-build guess** — the predecessor's `FORGE:INVESTIGATOR` "Affected Files" list, or a raw issue-body parse if no investigation existed yet. Once a predecessor reaches FAILED, GATED, **or DONE**, that guess must be checked against ground truth (the predecessor's actual PR diff, or the absence of any PR) before the edge is allowed to keep blocking a dependent or to inject a same-file brief. Without this, a predecessor that reaches `needs-human` or `workflow:invalid` having never touched the guessed shared file (or never opened a PR at all) leaves its dependents gated/skipped on a conflict that never existed — and on the happy path, an over-serialized chain is never reconciled at all and stays serialized for its entire life (forge#2848).
 
 ```bash
 verify_file_overlap_edge() {
@@ -1010,9 +1308,25 @@ verify_file_overlap_edge() {
   # a MERGED PR would already classify the predecessor DONE, not FAILED/GATED — so this filter
   # also guarantees `gh pr diff` below targets a live, still-open branch rather than an
   # abandoned PR whose branch may since have been force-deleted (e.g. by /cleanup).
+  #
+  # forge#2848 — the DONE call site widens what this can surface: for a DONE predecessor
+  # the live PR is MERGED, not OPEN. That is the *better* case, not a problem — a merged
+  # PR's diff is ground truth rather than a still-moving branch, and `gh pr diff` serves it
+  # from the API, so it keeps working after the head branch is deleted on merge. The
+  # CLOSED-unmerged exclusion is unchanged and still correct for all three call sites.
   local PRED_PR
+  local PRED_PR_EXIT
   PRED_PR=$(gh pr list -R {GH_REPO} --state all --search "\"Closes #${PRED}\" in:body" \
-    --json number,state --jq '[.[] | select(.state != "CLOSED")][0].number // empty' 2>/dev/null || echo "")
+    --json number,state --jq '[.[] | select(.state != "CLOSED")][0].number // empty' 2>/dev/null)
+  PRED_PR_EXIT=$?
+
+  if [ "$PRED_PR_EXIT" -ne 0 ]; then
+    # Fail-safe: could not determine whether a live predecessor PR exists (transient API
+    # error, rate limit, or search-index lag). Keep the edge rather than conflating a failed
+    # lookup with confirmed absence of a PR and dropping a real conflict.
+    echo "KEEP"
+    return
+  fi
 
   if [ -z "$PRED_PR" ]; then
     # Predecessor reached a terminal/gated state having never opened a PR (or only ever had
@@ -1062,16 +1376,28 @@ verify_file_overlap_edge() {
 }
 ```
 
-**Call sites**: item 6 (FAILED handling, below) and item 6.5 (GATED handling, below) both call this helper — once per `EDGE_KIND`-tagged predecessor edge — before cascading a skip or tracking `blocked-on-human-merge`. `phase-3-dependency.md`'s wake/compaction reconstruction block calls the identical logic (mirrored verbatim, not re-derived) for the case where the predecessor resolves after the orchestrator session has already ended — see that file's "Orchestrator state reconstruction on wake / after compaction" section. This mirroring is deliberate: keeping the check in exactly one function definition, called (not reimplemented) from both files, avoids the same drift class forge#1812 had to fix once already for DONE/GATED/FAILED classification itself.
+**Call sites**: item 6 (FAILED handling, below), item 6.5 (GATED handling, below), and the DONE arm of the core streaming dispatch loop (below — see "DONE-path edge re-verification") all call this helper — once per `EDGE_KIND`-tagged predecessor edge — before cascading a skip or tracking `blocked-on-human-merge`. `phase-3-dependency.md`'s wake/compaction reconstruction block calls the identical logic (mirrored verbatim, not re-derived) for the case where the predecessor resolves after the orchestrator session has already ended — see that file's "Orchestrator state reconstruction on wake / after compaction" section. This mirroring is deliberate: keeping the check in exactly one function definition, called (not reimplemented) from both files, avoids the same drift class forge#1812 had to fix once already for DONE/GATED/FAILED classification itself.
 
 **Recursive cascade note (item 6 only)**: when a dependent `DEP` is itself marked "skipped — dependency failed" (edge confirmed `KEEP`, not dropped), `DEP` becomes the new FAILED anchor for its own direct dependents — re-run this same `verify_file_overlap_edge` check at that next hop too, rather than assuming every transitive descendant is unconditionally skipped. A grandchild dependent whose only path to the failure runs through a spurious (droppable) edge one hop down must not be skipped just because its parent was.
 
-**Never called from**: the DONE branch (that predecessor's code is already merged — the edge, if real, is already resolved) or the `IN_PROGRESS` branch (nothing to re-verify yet — the predecessor hasn't concluded).
+**Never called from**: the `IN_PROGRESS` branch (nothing to re-verify yet — the predecessor hasn't concluded).
+
+**DONE-path edge re-verification** <!-- Added: forge#2848 --> — the DONE branch *does* call this helper, and it is the only call site that fires on the happy path. Be precise about what it buys, because the obvious reading is wrong:
+
+**It does NOT release the dependent.** A DONE predecessor already satisfies its own edge — see the `;; # satisfied` arm and the `ALL_PREDS_DONE` gate below. Dropping an edge whose predecessor is already DONE releases nobody, so re-verification alone cannot re-parallelize anything. What it actually buys is two things:
+
+1. **Suppressing a spurious same-file brief.** The DONE arm spends up to three `gh api` comment fetches per edge and then injects a `SAME_FILE_BRIEF` excerpt into the dependent's dispatch context. When the predecessor's real diff never touched the guessed file, that brief is not merely wasted tokens — it actively misleads the agent into coordinating on a file the predecessor never wrote. Verifying **before** those fetches skips all three calls and the brief.
+2. **Producing the disproof signal that enables re-derivation.** This is the part that actually re-parallelizes. A `DROP` on a `body-fallback`-provenance edge is evidence that the whole cohort's extraction is suspect: the first real diff has just contradicted the guess the chain was built on. By that point the still-blocked descendants have been investigated and possibly contracted, so re-running Layer 1 extraction against those now-higher-provenance sources and dropping edges that no longer hold is what collapses the chain. This is the step an operator performed by hand in the batch that motivated forge#2848; wiring it here makes it automatic.
 
 **Core streaming dispatch loop**: After processing each agent completion, check the DAG for newly unblocked issues. If any issue now has all predecessors classified `DONE`, dispatch it immediately (run Steps 4A.pre.0, 4A.pre, and 4A for the newly ready issues). This is the key difference from the wave model — issues dispatch as soon as their specific predecessors complete, not after an entire group finishes.
 
 ```bash
 # After each agent completion, check for newly ready issues:
+READINESS_RESCAN=true
+while [ "$READINESS_RESCAN" = "true" ]; do
+  # Re-derivation can remove an unresolved predecessor from an issue that this
+  # pass has already visited. Repeat the scan so it can dispatch this cycle.
+  READINESS_RESCAN=false
 for BLOCKED_NUM in {all_blocked_issue_numbers}; do
   ALL_PREDS_DONE=true
   ANY_PRED_GATED=false
@@ -1089,6 +1415,100 @@ for BLOCKED_NUM in {all_blocked_issue_numbers}; do
         EDGE_TYPE="${EDGE_KIND["${PRED}:${BLOCKED_NUM}"]:-}"
         if [ -n "$EDGE_TYPE" ] && [ -z "${EDGE_BRIEFED["${PRED}:${BLOCKED_NUM}"]:-}" ]; then
           EDGE_BRIEFED["${PRED}:${BLOCKED_NUM}"]=1
+
+          # DONE-path edge re-verification (forge#2848). Runs FIRST — before the three
+          # `gh api` brief fetches below — so a disproven edge costs zero extra API calls
+          # and injects no brief. EDGE_BRIEFED is already set above, so a DROP is not
+          # retried on the next completion cycle.
+          #
+          # Fail-safe direction is unchanged: verify_file_overlap_edge returns KEEP on any
+          # fetch failure, so a transient API error can only ever preserve the brief, never
+          # silently suppress a real one.
+          EDGE_VERDICT=$(verify_file_overlap_edge "$PRED" "$BLOCKED_NUM")
+          if [ "$EDGE_VERDICT" = "DROP" ]; then
+            echo "DONE-path re-verification: edge #${PRED} → #${BLOCKED_NUM} (${EDGE_TYPE}, files: ${EDGE_FILES["${PRED}:${BLOCKED_NUM}"]:-?}) DROPPED — #${PRED}'s merged diff never touched the guessed file. Skipping same-file brief."
+
+            # Leave SAME_FILE_BRIEF[$BLOCKED_NUM] UNSET rather than setting it empty —
+            # the dispatch-context builder treats unset as the no-op case, and an empty
+            # string would render an orphaned "shared file context" heading with nothing
+            # under it.
+
+            # Cohort re-derivation (forge#2848) — the step that actually releases
+            # dependents. Gated on `body-fallback` provenance only: a DROP against a
+            # contract- or investigation-derived list is a one-off miss, but a DROP
+            # against a raw-issue-body scrape is evidence the whole cohort's extraction
+            # is suspect (see phase-3-dependency.md Layer 4's cohort-confidence guidance).
+            if [ "${FILE_SOURCE[$PRED]:-}" = "body-fallback" ] && [ -n "$AFFECTED_FILES_SCRIPT" ]; then
+              # Re-derive only direct descendants of this DONE predecessor that
+              # are still blocked now. This intentionally excludes unrelated
+              # blocked issues and descendants whose PRED edge was already removed.
+              STILL_BLOCKED_DESCENDANTS=()
+              for CANDIDATE in {all_blocked_issue_numbers}; do
+                case " ${PREDECESSORS[$CANDIDATE]:-} " in
+                  *" $PRED "*) STILL_BLOCKED_DESCENDANTS+=("$CANDIDATE") ;;
+                esac
+              done
+              for DESC in "${STILL_BLOCKED_DESCENDANTS[@]}"; do
+                # Memoize conclusive results per descendant per batch. An inconclusive
+                # extraction gets one retry so a transient failure or pre-contract
+                # attempt does not permanently foreclose re-derivation. The two-attempt
+                # cap preserves an O(descendants) API budget for the hot dispatch loop.
+                [ -n "${EDGE_REDERIVED[$DESC]:-}" ] && continue
+                REDERIVE_ATTEMPTS=${EDGE_REDERIVE_ATTEMPTS[$DESC]:-0}
+                [ "$REDERIVE_ATTEMPTS" -ge 2 ] && continue
+                EDGE_REDERIVE_ATTEMPTS[$DESC]=$((REDERIVE_ATTEMPTS + 1))
+
+                # Re-run Layer 1 extraction. By now DESC has been investigated and
+                # possibly contracted, so this typically returns a higher-provenance
+                # list than the body scrape the original edge was built from. Resolve
+                # the helper through the runtime path, never a bare `bash scripts/...`
+                # (#2794) — same resolver precedence as phase-3-dependency.md Layer 1.
+                REDERIVE_OUT=$(bash "$AFFECTED_FILES_SCRIPT" "$DESC" -R {GH_REPO})
+                REDERIVE_PROV=$(echo "$REDERIVE_OUT" | head -1 | sed 's/^PROVENANCE=//')
+                REDERIVE_FILES=$(echo "$REDERIVE_OUT" | tail -n +2)
+
+                # Fail-safe: only act on a CONFIRMED-empty overlap. `error` means the
+                # extraction was inconclusive (a `gh` call failed — forge#2504), and
+                # `none`/`body-fallback` mean we learned nothing better than what we
+                # already had. In all three cases keep every edge untouched.
+                case "$REDERIVE_PROV" in
+                  contract-deliverables|affected-files-section) EDGE_REDERIVED[$DESC]=1 ;;
+                  *) echo "  re-derivation for #${DESC} inconclusive (provenance: ${REDERIVE_PROV}) — keeping all edges"; continue ;;
+                esac
+
+                # Re-derive only PRED's edge into DESC. PRED is the DONE predecessor
+                # whose merged diff just disproved this edge; other predecessors may
+                # still be building and must retain their serialization edges.
+                for DESC_PRED in "$PRED"; do
+                  [ -z "${EDGE_KIND["${DESC_PRED}:${DESC}"]:-}" ] && continue
+                  STILL_OVERLAPS=false
+                  for EF in ${EDGE_FILES["${DESC_PRED}:${DESC}"]:-}; do
+                    [ -z "$EF" ] && continue
+                    EF_CLEAN="${EF%/}"
+                    EF_ESCAPED=$(printf '%s' "$EF_CLEAN" | sed 's/[.[\*^$()+?{|]/\\&/g')
+                    if echo "$REDERIVE_FILES" | grep -qE "(^|/)${EF_ESCAPED}(/|$)"; then
+                      STILL_OVERLAPS=true
+                      break
+                    fi
+                  done
+                  if [ "$STILL_OVERLAPS" = "false" ]; then
+                    echo "  re-derived edge #${DESC_PRED} → #${DESC}: DROPPED — '${EDGE_FILES["${DESC_PRED}:${DESC}"]}' absent from #${DESC}'s refreshed ${REDERIVE_PROV} file list"
+                    unset 'EDGE_KIND['"${DESC_PRED}:${DESC}"']'
+                    unset 'EDGE_FILES['"${DESC_PRED}:${DESC}"']'
+                    # Remove DESC_PRED from PREDECESSORS[$DESC] so the ALL_PREDS_DONE
+                    # gate below stops waiting on it. DESC becomes dispatch-eligible on
+                    # this same cycle if that was its last outstanding predecessor.
+                    PREDECESSORS[$DESC]=$(echo "${PREDECESSORS[$DESC]}" | tr ' ' '\n' | grep -vx "$DESC_PRED" | tr '\n' ' ')
+                    READINESS_RESCAN=true
+                  fi
+                done
+              done
+            fi
+
+            # Edge disproven — nothing further to do for this (PRED, BLOCKED_NUM) pair.
+            continue
+          fi
+
           SHARED_FILE="${EDGE_FILES["${PRED}:${BLOCKED_NUM}"]:-}"
 
           # Prefer FORGE:BUILDER (the concrete "what changed" record). Fall back to
@@ -1140,6 +1560,7 @@ for BLOCKED_NUM in {all_blocked_issue_numbers}; do
     # Do NOT dispatch. Do NOT mark skipped. Tracked via item 6.5.
   fi
 done
+done
 # Run Steps 4A.pre.0 → 4A.pre → 4A for newly ready issues. Step 4A's own dispatch-batch
 # computation (the HEADROOM/DISPATCH_NOW logic, forge#1912) is what actually caps this —
 # "newly ready" here just means "eligible," not "guaranteed to dispatch this cycle." Any
@@ -1299,11 +1720,7 @@ done
    # After CLAIM_RELEASED for issue NUM:
    # Read all active FORGE:CLAIM annotations from coordination issue
    if [ -n "${FORGE_COORD_ISSUE:-}" ] && [ -n "${COORD_NUM:-}" ]; then
-     ACTIVE_CLAIMS=$(gh api repos/{GH_REPO}/issues/${COORD_NUM}/comments \
-       --jq '[.[] | select(.body | contains("<!-- FORGE:CLAIM -->")) |
-              select(.body | contains("<!-- FORGE:CLAIM_RELEASED -->") | not)] |
-             map({holder: (.body | capture("\\*\\*Holder\\*\\*: (?P<h>[^\\n]+)").h),
-                  files: (.body | capture("\\*\\*Files\\*\\*: (?P<f>[^\\n]+)").f)})' 2>/dev/null || echo '[]')
+      ACTIVE_CLAIMS=$(read_active_claims "$COORD_NUM" 2>/dev/null || echo '[]')
      # For each still-blocked issue in a Layer-2/4 pair: check if its claim's file set
      # is disjoint from all remaining active claims. If so, mark it ready.
      # (Layer-1 and Layer-3 edges are never relaxed — this check is Layer-2/4 only.)
@@ -1367,7 +1784,7 @@ done
            run_in_background=true,
            prompt="You are remediating GitHub PR #{GATING_PR} for the {PROJECT_NAME} project (repo: {GH_REPO}), which is currently held at `needs-human` on its linked issue #{PRED}.
 
-**YOUR MISSION**: Invoke `Skill(skill='work-on', args='{GATING_PR} --remediate --issue {PRED} --repo {GH_REPO} --gh-flag {GH_FLAG}')` and let it run to completion. This is a self-contained flow: it checks out the PR branch, fixes any fixable review findings, re-reviews, and either auto-lands the PR, holds it at `workflow:awaiting-merge` for a human, re-escalates back to `needs-human`, or reports the block as policy-level and unfixable. Do NOT intervene manually — do not run raw git/gh commands yourself.
+**YOUR MISSION**: Invoke `Skill(skill='work-on', args='{GATING_PR} --remediate --issue {PRED} --repo {GH_REPO} --gh-flag {GH_FLAG}')` and let it run to completion. This is a self-contained flow: it classifies the gate first, replaces `needs-human` with `workflow:in-review` only for fixable remediation, checks out the PR branch, fixes any fixable review findings, re-reviews, and either auto-lands the PR, holds it at `workflow:awaiting-merge` for a human, re-escalates back to `needs-human`, or reports the block as policy-level and unfixable. Do NOT intervene manually — do not run raw git/gh commands yourself.
 
 **DO NOT STOP EARLY**: if the Skill call returns without a terminal `REMEDIATE_RESULT.status`, invoke it again — it re-reads GitHub state and resumes. Terminal statuses are: `COMPLETE`, `ALREADY_DONE`, `UNFIXABLE`, `BLOCKED`.
 
@@ -1513,6 +1930,7 @@ Gating predecessor #${NUM} reached \`workflow:merged\` — dispatching now. (Was
    ```
    ✓ #{NUMBER} — {title} → PR #{PR} merged to {target}
    ✗ #{NUMBER} — {title} → {reason for failure}
+   ⚠ #{NUMBER} — {title} → PR #{PR} blocked: review panel degraded (full fresh-session re-review required)
    ⚠ #{NUMBER} — {title} → PIPELINE BYPASS (no /work-on — PR invalid)
    ⏸ #{NUMBER} — {title} → PR #{PR} awaiting-merge (remediated + re-approved, `main`/deploy-gate base — human merge only, no diagnosis needed; non-`main` bases now auto-land to `workflow:merged` via remediate.md M7, forge#2570)
    🔗 #{NUMBER} — {title} → blocked-on-human-merge (gated by #{PRED}, will auto-dispatch on #{PRED} merge)
@@ -1538,6 +1956,8 @@ Gating predecessor #${NUM} reached \`workflow:merged\` — dispatching now. (Was
    dependent itself has no problem at all, it is simply waiting on someone else's merge. See Phase 6's
    "Merge-Ready" report section (`phase-6-report.md` Step 6A.5/6B) for the batch-level rollup.
 
+   Before printing a terminal status for a PR, inspect its labels. If it has `review-degraded`, print the dedicated blocked line above and retain the issue's `needs-human` state. Never report a degraded review as merged or awaiting-merge.
+
 9. **Run staging integrity check** (from Step 4A-pre) if the completed agent merged a PR targeting staging.
 
 **Termination condition**: All issues in the DAG have reached `DONE` or `FAILED` (merged, invalid, or skipped due to dependency failure) — OR are `blocked-on-human-merge` (item 6.5) with no further dispatchable work remaining in the batch. These two outcomes are reported differently: a batch where every issue is `DONE`/`FAILED` is a **clean drain**; a batch where one or more issues remain `blocked-on-human-merge` is a **paused drain** — the active dispatch loop stops (there is nothing left to do until a human merges a gating PR) but this MUST be reported as paused, not as fully complete (see `phase-6-report.md`'s `🔗 Blocked-on-Merge` section). `needs-human` predecessors with no open PR are neither — they remain GATED indefinitely until either a PR appears (dependent moves to blocked-on-human-merge) or the predecessor itself resolves; do not treat isolated `needs-human` issues with no dependents as blocking termination. When either drain condition is met, check whether deferred review-spawned findings exist (accumulated in `DEFERRED_FINDINGS` during Step 4C). If deferred findings exist → proceed to Step 4F (Completion Sweep). If no deferred findings → **call `release_orchestrator_lease()` (Step 4A-pre.-1)** — this is a clean/paused drain of this session's own dispatch loop, so the lease should not be left held for a now-idle session — then proceed to Phase 5. <!-- Added: forge#2627 -->
@@ -1698,6 +2118,56 @@ that mode only exists as the explicit, one-shot `--include-backlog` opt-in at Ph
 never silently widen to the full backlog regardless of any flag, since nothing here is a
 human-in-the-loop request. <!-- Added: forge#2628 -->
 
+### Step 4C.0: Full-repository actionable-issue intake (`policy: all` only)
+
+An operator-authorised `orchestration.cascade.policy: all` run must also check for newly-created
+open issues that its own agents did not report and that lack `review-finding`. Run this sweep
+after every five terminal completions, before the next dispatch cycle. It is not a cascade
+replacement: Step 4C's `BATCH_T0` filter still governs review-finding recursion.
+
+At batch start, seed `SEEN_OPEN_ISSUES` with the initial resolved issue set. On each sweep, list
+the complete open set (`gh issue list --state open --limit 500 --json number,title,labels`), diff
+it against `SEEN_OPEN_ISSUES`, then mark every returned number seen whether or not it is admitted.
+For each newly-seen issue, add it to the normal Phase 3 DAG intake only when it has no terminal or
+in-progress workflow label, `needs-human`, or `workflow:decomposed`; preserve its labels and
+record why every excluded issue was skipped. Do not filter on `review-finding`, author, creation
+time, or agent trajectory. This is how CI-created issues enter an all-policy run without silently
+adopting pre-existing work in other policies.
+
+```bash
+if [ "$CASCADE_POLICY_NAME" = "all" ] && [ "$((TERMINAL_COMPLETIONS % 5))" -eq 0 ] && \
+   [ "$TERMINAL_COMPLETIONS" -gt "$FULL_REPO_SWEEP_COUNT" ]; then
+  FULL_REPO_SWEEP_COUNT=$TERMINAL_COMPLETIONS
+  FULL_REPO_OPEN=$(gh issue list -R {GH_REPO} --state open --limit 500 --json number,title,labels)
+  while IFS= read -r ISSUE; do
+    NUM=$(echo "$ISSUE" | jq -r '.number')
+    [ -n "${SEEN_OPEN_ISSUES[$NUM]:-}" ] && continue
+    SEEN_OPEN_ISSUES[$NUM]=1
+    LABELS=$(echo "$ISSUE" | jq -r '[.labels[].name] | join(",")')
+    if echo "$LABELS" | grep -qE '(^|,)(workflow:(merged|invalid|awaiting-merge|building|in-review|decomposed)|needs-human)(,|$)'; then
+      echo "Full-repo intake: #${NUM} seen but not admitted (terminal, in-progress, or human-gated)"
+      continue
+    fi
+    FULL_REPO_INTAKE+=("$NUM")
+    echo "Full-repo intake: admitted newly-seen actionable issue #${NUM}"
+  done < <(echo "$FULL_REPO_OPEN" | jq -c '.[]')
+  # Feed FULL_REPO_INTAKE through the existing Phase 3 extraction/DAG/claims gates.
+fi
+```
+
+### Step 4C.1: Mechanical automated-alert deduplication (`policy: all` opt-in)
+
+`orchestration.cascade.dedup_automated: true` permits a narrow exception to the normal
+no-dedup rule for newly-seen automated alerts. Select one lowest-numbered canonical issue and
+close another issue only when all of these are true: both authors are bot/app accounts; normalized
+titles are identical; the generator identity is identical; the triggering condition is identical;
+and the closing comment links the retained canonical issue. Never apply title similarity to a
+human-authored report, or when generator/trigger provenance is absent or differs. The reference
+predicate is `canDeduplicateAutomatedAlert()` in `bin/engine/admission.mjs`.
+
+This opt-in handles mechanically identical alerts, not substantive bug adjudication. All other
+possible duplicates remain separate and go through investigation.
+
 ```bash
 # Method 1: Read TRAJECTORY comments from completed issues for "Finding issues" row
 for NUM in {completed_issue_number}; do
@@ -1718,13 +2188,37 @@ gh issue list -R {GH_REPO} --state open --search "label:review-finding created:>
 
 **If review-finding issues were spawned:**
 
+**Amplification accounting (MANDATORY, before cascade admission):** Count every finding created by this batch, including findings later deferred by any cascade rule. After each merged unit, compute `FINDINGS_SPAWNED / MERGED_UNITS`, append the value to `AMPLIFICATION_RATIO_HISTORY`, and print a convergence warning when the latest `CONVERGENCE_WINDOW` observations are all `>= 1.0`. A high ratio is a signal, not a failure: valuable deep review findings can legitimately raise it.
+
+For each finding, extract its source PR from `**Source**: PR #N` and increment `FINDINGS_BY_SOURCE_PR[N]`. Classify it as a **same-lineage refinement** only when that source PR closes a `review-finding` issue and both that parent finding and this finding name the same affected file; otherwise classify it as **new surface**. Record the finding number in `REFINEMENT_FINDINGS` or `NEW_SURFACE_FINDINGS` respectively. If provenance or a file path cannot be established, classify as new surface conservatively; never suppress it as a refinement.
+
+When `CASCADE_MAX_AMPLIFICATION` is not `off`, and the current ratio is greater than that ceiling, defer only newly discovered entries in `REFINEMENT_FINDINGS` with reason `amplification bound exceeded (same-lineage refinement)`. Add them to `DEFERRED_FINDINGS` and `DEFERRED_REASONS` so Step 4F re-evaluates them after the batch drains. Do not apply this bound to new-surface findings, P1/P2 findings, or any finding when the option is `off`.
+
+```bash
+# Run once for each completed issue before collecting its findings. Only merged
+# units advance the denominator; invalid/skipped units do not imply delivered work.
+if gh issue view "$NUM" -R {GH_REPO} --json labels \
+  --jq '[.labels[].name | select(. == "workflow:merged")] | length' | grep -qx '1'; then
+  MERGED_UNITS=$((MERGED_UNITS + 1))
+  AMPLIFICATION_RATIO=$(awk "BEGIN { printf \"%.2f\", $FINDINGS_SPAWNED / $MERGED_UNITS }")
+  AMPLIFICATION_RATIO_HISTORY+=("$AMPLIFICATION_RATIO")
+  if [ "${#AMPLIFICATION_RATIO_HISTORY[@]}" -ge "$CONVERGENCE_WINDOW" ]; then
+    RECENT_RATIOS=("${AMPLIFICATION_RATIO_HISTORY[@]: -$CONVERGENCE_WINDOW}")
+    if printf '%s\n' "${RECENT_RATIOS[@]}" | awk '$1 < 1 { exit 1 }'; then
+      echo "CONVERGENCE WARNING: amplification has remained >= 1.0 for ${CONVERGENCE_WINDOW} merged units (${AMPLIFICATION_RATIO} current). This can be productive review refinement, but the batch is not shrinking."
+    fi
+  fi
+fi
+
+```
+
 **Cascade control (MANDATORY — run before folding findings into the DAG):**
 
 For each spawned finding, determine whether it should be **executed** or **deferred**:
 
 **Evaluation order** (first matching rule wins):
 0. **Batch fully human-gated** (`BATCH_FULLY_GATED == true`, always defer, even for P1/P2) <!-- Added: forge#1814 -->: The original batch (see Step 4B item 6.7) has exhausted into DONE/FAILED/GATED with nothing left `IN_PROGRESS` — the real blockers are the GATED issues, not a lack of dispatchable findings. Dispatching a new review-finding here cannot produce net batch progress; it only inflates the open-issue count while the productive path waits on a human merge. Always defer, checked before generation and priority. Rationale: this is the idle/backpressure policy this issue adds — without it, rule 2 (below) unconditionally executes P1/P2 findings regardless of how gated the rest of the batch is, which is the root cause of the net-negative churn this policy exists to stop. **Configurable** via `orchestration.cascade.defer_on_batch_gated` (default `true`; `false` under `policy: all` — forge#2234).
-1. **Generation ≥ 2** (always defer, even for P1/P2, for autonomous mid-run cascade — see scope note below): Finding was spawned by an issue that was itself a review-finding. Check the source issue's labels for `review-finding` — if the source has that label, the new finding is generation 2. Always defer within this Step 4C triage pass. Rationale: gen-2+ cascade is theoretically unbounded — cap it here. **Scope**: this rule caps *autonomous* cascade — findings discovered and re-triaged automatically during an unattended run. It is not a cap on what a human can explicitly request. When an operator directly asks for cascade/review-finding work via `phase-1-resolve.md`'s dedicated `cascade`/`review-findings`/`findings` resolution (with `--include-deferred`/`--allow-gen2`, or the `orchestration.cascade.max_generation` config lever from #2234), those findings enter the DAG through Phase 1 resolution, not through this Step 4C mid-run triage — this rule still defers anything Step 4C itself discovers mid-run, including inside a human-requested gen≥2 batch (see recursion safety below). **Not configurable here** — `orchestration.cascade.max_generation` governs Phase 1 resolve-time admission only (see `phase-1-resolve.md` "Cascade / Review-Finding Resolution"); this Step 4C rule stays an absolute autonomous-cascade cap regardless of policy, including `policy: all`. <!-- Added: forge#2231 -->
+1. **Generation ≥ 2** (always defer from individual autonomous dispatch, even for P1/P2, for mid-run cascade — see scope note below): Finding was spawned by an issue that was itself a review-finding. A P3 finding at or below the finite `orchestration.cascade.batch_max_generation` ceiling (default 2) is retained only as a candidate for the bounded P3 batch pass; it remains deferred if no batch forms. A formed batch records `FORGE:BATCH_MAX_GENERATION` and its generation-2+ members. No P1/P2, or finding above that ceiling, takes this exception. Rationale: gen-2+ individual cascade is theoretically unbounded — cap it here while permitting one auditable aggregation unit. **Scope**: this rule caps *autonomous* cascade — findings discovered and re-triaged automatically during an unattended run. It is not a cap on what a human can explicitly request. When an operator directly asks for cascade/review-finding work via `phase-1-resolve.md`'s dedicated `cascade`/`review-findings`/`findings` resolution (with `--include-deferred`/`--allow-gen2`, or the `orchestration.cascade.max_generation` config lever from #2234), those findings enter the DAG through Phase 1 resolution, not through this Step 4C mid-run triage. `batch_max_generation` is separate from `max_generation`, and remains finite even under `policy: all`. <!-- Added: forge#2231, forge#2849 -->
 2. **Priority override** (P1 or P2 → always execute): If the finding is labeled P1 or P2, skip all remaining heuristics and execute. Rationale: high-priority findings must never be suppressed by keyword matching.
 3. **Comment/typo heuristic** (P3 and below only): Finding title contains the word "comment" or "typo" (case-insensitive). These are 1-line cosmetic fixes that do not block other work. **Configurable** via `orchestration.cascade.keyword_heuristic` (default `true`; `false` under `policy: all` — forge#2234).
 4. **P3 + same-file overlap**: Finding is labeled `P3` AND the file it targets overlaps with ANY file already in the current batch (active or queued in the DAG). Rationale: same-file P3 findings add predecessor edges that serialize agents — one finding per original issue increases wall-clock time with no proportional value. **Configurable** via `orchestration.cascade.p3_same_file_defer` (default `true`; `false` under `policy: all` — forge#2234).
@@ -1760,6 +2254,22 @@ ALL_BATCH_FILES=$(echo "$ALL_BATCH_FILES" | sort -u | grep -v '^$')
 ```
 
 ```bash
+# Use the same bounded ancestor walk as Phase 1 so batching records actual depth,
+# not just whether the immediate source is a review finding.
+compute_finding_generation() {
+  local body="$1" generation=1 hops=0 source_num source_data
+  while [ "$hops" -lt 10 ]; do
+    source_num=$(echo "$body" | grep -ioE 'spawned from issue #[0-9]+|source issue[: #]+[0-9]+' | head -1 | grep -oE '[0-9]+$')
+    [ -z "$source_num" ] && break
+    source_data=$(gh issue view "$source_num" -R {GH_REPO} --json labels,body 2>/dev/null) || break
+    echo "$source_data" | jq -e '[.labels[].name] | index("review-finding")' >/dev/null 2>&1 || break
+    generation=$((generation + 1))
+    body=$(echo "$source_data" | jq -r '.body')
+    hops=$((hops + 1))
+  done
+  echo "$generation"
+}
+
 # For each finding, check its priority label and generation
 # NOTE: DEFERRED_FINDINGS, QUEUED_FINDINGS, and DEFERRED_REASONS are declared at
 # batch scope in Step 4A.pre — do NOT re-initialize them here (Step 4C runs per-agent).
@@ -1767,6 +2277,45 @@ for FINDING_NUM in {spawned_finding_numbers}; do
   FINDING_DATA=$(gh issue view $FINDING_NUM -R {GH_REPO} --json labels,title,body,updatedAt \
     --jq '{labels: [.labels[].name], title: .title, body: .body, updatedAt: .updatedAt}')
 
+  # Count each finding once and retain source provenance for the final per-PR
+  # breakdown. Missing source/file evidence fails open as new surface.
+  FINDING_BODY=$(echo "$FINDING_DATA" | jq -r '.body')
+  SOURCE_PR=""
+  if [[ "$FINDING_BODY" =~ \*\*[Ss]ource\*\*:[[:space:]]*[Pp][Rr][[:space:]]*\#([0-9]+) ]]; then
+    SOURCE_PR="${BASH_REMATCH[1]}"
+  fi
+  if [ -z "${AMPLIFICATION_FINDING_SEEN[$FINDING_NUM]:-}" ]; then
+    AMPLIFICATION_FINDING_SEEN[$FINDING_NUM]=1
+    FINDINGS_SPAWNED=$((FINDINGS_SPAWNED + 1))
+    [ -n "$SOURCE_PR" ] && FINDINGS_BY_SOURCE_PR[$SOURCE_PR]=$(( ${FINDINGS_BY_SOURCE_PR[$SOURCE_PR]:-0} + 1 ))
+  fi
+  FINDING_IS_REFINEMENT=false
+  FINDING_FILE_FOR_LINEAGE=$(echo "$FINDING_BODY" | grep -oE '`[^`]+\.(py|tsx?|jsx?|sql|json|ya?ml|sh|md)`' | head -1 | tr -d '`')
+  if [ -n "$SOURCE_PR" ] && [ -n "$FINDING_FILE_FOR_LINEAGE" ]; then
+    SOURCE_ISSUE=""
+    SOURCE_PR_BODY=$(gh pr view "$SOURCE_PR" -R {GH_REPO} --json body --jq '.body' 2>/dev/null || echo "")
+    SOURCE_PR_BODY_LOWER=$(echo "$SOURCE_PR_BODY" | tr '[:upper:]' '[:lower:]')
+    if [[ "$SOURCE_PR_BODY_LOWER" =~ (close[sd]?|fix(e[sd])?|resolve[sd]?)[[:space:]]+\#([0-9]+) ]]; then
+      SOURCE_ISSUE="${BASH_REMATCH[3]}"
+    fi
+    if [ -n "$SOURCE_ISSUE" ]; then
+      PARENT_DATA=$(gh issue view "$SOURCE_ISSUE" -R {GH_REPO} --json labels,body \
+        --jq '{labels: [.labels[].name], body: .body}' 2>/dev/null || echo '{}')
+      PARENT_FILE=$(echo "$PARENT_DATA" | jq -r '.body // ""' | grep -oE '`[^`]+\.(py|tsx?|jsx?|sql|json|ya?ml|sh|md)`' | head -1 | tr -d '`')
+      if echo "$PARENT_DATA" | jq -e '[.labels[] | select(. == "review-finding")] | length > 0' >/dev/null && \
+         [ "$PARENT_FILE" = "$FINDING_FILE_FOR_LINEAGE" ]; then
+        FINDING_IS_REFINEMENT=true
+        REFINEMENT_FINDINGS[$FINDING_NUM]="$SOURCE_PR"
+      else
+        NEW_SURFACE_FINDINGS[$FINDING_NUM]="$SOURCE_PR"
+      fi
+    else
+      NEW_SURFACE_FINDINGS[$FINDING_NUM]="$SOURCE_PR"
+    fi
+  else
+    NEW_SURFACE_FINDINGS[$FINDING_NUM]="${SOURCE_PR:-unknown}"
+  fi
+
   # Code-branch repair guard (MANDATORY — before priority/defer heuristics below).
   # A review-finding with no **Code branch** annotation, whose parent PR's base is
   # not the staging fast lane, would otherwise silently fall through to
@@ -1831,30 +2380,33 @@ for FINDING_NUM in {spawned_finding_numbers}; do
           # as its own outcome and fail closed, mirroring the concurrent-edit branch below
           # rather than silently falling through to the unprotected write.
           echo "REPAIR: #${FINDING_NUM} skipped — freshness re-fetch failed (network error or API rate limit); cannot verify no concurrent edit occurred, failing closed instead of risking a silent clobber"
-          # forge#2584: stage the body in a mktemp file and deliver it via --body-file
-          # instead of interpolating finding-derived variables (${FINDING_NUM},
-          # ${REPAIR_SOURCE_PR}, ${REPAIR_PARENT_BASE}, ${FINDING_UPDATED_AT_SNAPSHOT})
-          # directly into a double-quoted --body argument at the gh call site — mirrors
-          # REPAIRED_BODY's existing printf-into-variable approach and the repo-wide
-          # mktemp + --body-file convention (forge#2198). mktemp avoids /tmp path
-          # collisions with other concurrently-running orchestrated agents.
-          GATE_BODY_TMPFILE="$(mktemp)"
+          # Scope the scratch name to both this finding and this orchestrator process.
+          # The marker read-back below detects a plausible-looking body substitution.
+          SCRATCHPAD="${FORGE_SCRATCHPAD:-$PWD/.forge-scratch}"
+          AGENT_TOKEN="${AGENT_ID:-${HOSTNAME:-orchestrator}-$$}"
+          mkdir -p "$SCRATCHPAD"
+          GATE_BODY_MARKER="FORGE:BODY-INTEGRITY:${FINDING_NUM}_freshness-gate_${AGENT_TOKEN}"
+          GATE_BODY_TMPFILE="$(mktemp "$SCRATCHPAD/${FINDING_NUM}_freshness-gate_${AGENT_TOKEN}.XXXXXX.md")"
           printf '%s' "<!-- FORGE:GATE_FAILURE -->
 ## Code Branch Repair Skipped — Freshness Re-fetch Failed
 
-Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${REPAIR_SOURCE_PR} bases on \`${REPAIR_PARENT_BASE}\` — not the staging fast lane. Automatic repair was skipped because the freshness re-fetch (\`gh issue view --json updatedAt\`) failed, so the concurrency guard could not confirm the issue body is still at the snapshot captured earlier in this iteration (\`${FINDING_UPDATED_AT_SNAPSHOT}\`). Proceeding with the write here would risk silently clobbering a concurrent edit with no way to verify. Human review required to confirm the current body state and, if still needed, re-apply the Code branch stamp manually. <!-- forge#2565 -->" > "$GATE_BODY_TMPFILE"
+Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${REPAIR_SOURCE_PR} bases on \`${REPAIR_PARENT_BASE}\` — not the staging fast lane. Automatic repair was skipped because the freshness re-fetch (\`gh issue view --json updatedAt\`) failed, so the concurrency guard could not confirm the issue body is still at the snapshot captured earlier in this iteration (\`${FINDING_UPDATED_AT_SNAPSHOT}\`). Proceeding with the write here would risk silently clobbering a concurrent edit with no way to verify. Human review required to confirm the current body state and, if still needed, re-apply the Code branch stamp manually. <!-- forge#2565 -->
+<!-- ${GATE_BODY_MARKER} -->" > "$GATE_BODY_TMPFILE"
           gh issue comment "$FINDING_NUM" -R {GH_REPO} --body-file "$GATE_BODY_TMPFILE" 2>/dev/null || true
+          gh api "repos/{GH_REPO}/issues/${FINDING_NUM}/comments" --jq '.[].body' | grep -Fqx "<!-- ${GATE_BODY_MARKER} -->" || { echo "ERROR: freshness-gate comment marker missing" >&2; exit 1; }
           rm -f "$GATE_BODY_TMPFILE"
           gh issue edit "$FINDING_NUM" -R {GH_REPO} --add-label needs-human 2>/dev/null || true  # freshness-recheck-failure path
         elif [ "$FINDING_UPDATED_AT_CURRENT" != "$FINDING_UPDATED_AT_SNAPSHOT" ]; then
           echo "REPAIR: #${FINDING_NUM} skipped — concurrent edit detected (updatedAt changed from ${FINDING_UPDATED_AT_SNAPSHOT} to ${FINDING_UPDATED_AT_CURRENT} since this iteration's initial read); flagging instead of repairing"
-          # forge#2584: mktemp + --body-file, same rationale as the freshness-recheck-failure path above.
-          CONCURRENT_EDIT_BODY_TMPFILE="$(mktemp)"
+          CONCURRENT_EDIT_BODY_MARKER="FORGE:BODY-INTEGRITY:${FINDING_NUM}_concurrent-edit_${AGENT_TOKEN}"
+          CONCURRENT_EDIT_BODY_TMPFILE="$(mktemp "$SCRATCHPAD/${FINDING_NUM}_concurrent-edit_${AGENT_TOKEN}.XXXXXX.md")"
           printf '%s' "<!-- FORGE:GATE_FAILURE -->
 ## Code Branch Repair Skipped — Concurrent Edit Detected
 
-Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${REPAIR_SOURCE_PR} bases on \`${REPAIR_PARENT_BASE}\` — not the staging fast lane. Automatic repair was skipped because the issue body was edited concurrently (\`updatedAt\` changed from \`${FINDING_UPDATED_AT_SNAPSHOT}\` to \`${FINDING_UPDATED_AT_CURRENT}\` between this run's initial read and the repair write). Overwriting the body now would have silently discarded that concurrent edit. Human review required to reconcile and, if still needed, re-apply the Code branch stamp manually. <!-- forge#2512 -->" > "$CONCURRENT_EDIT_BODY_TMPFILE"
+Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${REPAIR_SOURCE_PR} bases on \`${REPAIR_PARENT_BASE}\` — not the staging fast lane. Automatic repair was skipped because the issue body was edited concurrently (\`updatedAt\` changed from \`${FINDING_UPDATED_AT_SNAPSHOT}\` to \`${FINDING_UPDATED_AT_CURRENT}\` between this run's initial read and the repair write). Overwriting the body now would have silently discarded that concurrent edit. Human review required to reconcile and, if still needed, re-apply the Code branch stamp manually. <!-- forge#2512 -->
+<!-- ${CONCURRENT_EDIT_BODY_MARKER} -->" > "$CONCURRENT_EDIT_BODY_TMPFILE"
           gh issue comment "$FINDING_NUM" -R {GH_REPO} --body-file "$CONCURRENT_EDIT_BODY_TMPFILE" 2>/dev/null || true
+          gh api "repos/{GH_REPO}/issues/${FINDING_NUM}/comments" --jq '.[].body' | grep -Fqx "<!-- ${CONCURRENT_EDIT_BODY_MARKER} -->" || { echo "ERROR: concurrent-edit comment marker missing" >&2; exit 1; }
           rm -f "$CONCURRENT_EDIT_BODY_TMPFILE"
           gh issue edit "$FINDING_NUM" -R {GH_REPO} --add-label needs-human 2>/dev/null || true  # concurrent-edit path
         else
@@ -1865,13 +2417,15 @@ Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${R
           FINDING_DATA=$(gh issue view $FINDING_NUM -R {GH_REPO} --json labels,title,body,updatedAt \
             --jq '{labels: [.labels[].name], title: .title, body: .body, updatedAt: .updatedAt}')
         else
-          # forge#2584: mktemp + --body-file, same rationale as the two failure paths above.
-          REPAIR_FAILED_BODY_TMPFILE="$(mktemp)"
+          REPAIR_FAILED_BODY_MARKER="FORGE:BODY-INTEGRITY:${FINDING_NUM}_repair-failure_${AGENT_TOKEN}"
+          REPAIR_FAILED_BODY_TMPFILE="$(mktemp "$SCRATCHPAD/${FINDING_NUM}_repair-failure_${AGENT_TOKEN}.XXXXXX.md")"
           printf '%s' "<!-- FORGE:GATE_FAILURE -->
 ## Code Branch Repair Failed
 
-Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${REPAIR_SOURCE_PR} bases on \`${REPAIR_PARENT_BASE}\` — not the staging fast lane. Automatic repair (\`gh issue edit --body\`) failed. Without this annotation, \`/work-on\`'s investigation phase may look for the code on the wrong branch (staging, where it is absent) and misclassify this confirmed finding as invalid. Human review required. <!-- forge#2443 -->" > "$REPAIR_FAILED_BODY_TMPFILE"
+Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${REPAIR_SOURCE_PR} bases on \`${REPAIR_PARENT_BASE}\` — not the staging fast lane. Automatic repair (\`gh issue edit --body\`) failed. Without this annotation, \`/work-on\`'s investigation phase may look for the code on the wrong branch (staging, where it is absent) and misclassify this confirmed finding as invalid. Human review required. <!-- forge#2443 -->
+<!-- ${REPAIR_FAILED_BODY_MARKER} -->" > "$REPAIR_FAILED_BODY_TMPFILE"
           gh issue comment "$FINDING_NUM" -R {GH_REPO} --body-file "$REPAIR_FAILED_BODY_TMPFILE" 2>/dev/null || true
+          gh api "repos/{GH_REPO}/issues/${FINDING_NUM}/comments" --jq '.[].body' | grep -Fqx "<!-- ${REPAIR_FAILED_BODY_MARKER} -->" || { echo "ERROR: repair-failure comment marker missing" >&2; exit 1; }
           rm -f "$REPAIR_FAILED_BODY_TMPFILE"
           gh issue edit "$FINDING_NUM" -R {GH_REPO} --add-label needs-human 2>/dev/null || true  # repair-failure path
         fi
@@ -1908,7 +2462,8 @@ Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${R
   # all" sets this to false so an operator draining a backlog is never idle-gated.
   if [ "$CASCADE_DEFER_ON_BATCH_GATED" = "true" ] && [ "${BATCH_FULLY_GATED:-false}" = "true" ]; then
     DEFER=true; DEFER_REASON="batch fully human-gated — idle policy"
-  # Heuristic 1: Generation check — source issue has review-finding label (always defer, even for P1/P2)
+  # Heuristic 1: Generation check — source issue has review-finding label. Always defer
+  # individual dispatch; only bounded P3 aggregation can consume an eligible member.
   # NOT gated by orchestration.cascade.max_generation — this is Step 4C's autonomous
   # mid-run cascade cap, which stays absolute regardless of config (see forge#2231's
   # scope note above and phase-1-resolve.md's Cascade / Review-Finding Resolution
@@ -1917,9 +2472,17 @@ Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${R
   elif SOURCE_NUM=$(echo "$FINDING_DATA" | jq -r '.body' | grep -oP '(?i)spawned from issue #\K\d+|source issue[: #]+\K\d+' | head -1) && \
        [ -n "$SOURCE_NUM" ] && \
        gh issue view $SOURCE_NUM -R {GH_REPO} --json labels --jq '[.labels[].name]' 2>/dev/null | grep -q "review-finding"; then
-    DEFER=true; DEFER_REASON="generation >= 2 (source #${SOURCE_NUM} is also a review-finding)"
-  # Priority override: P1 or P2 always execute — skip remaining heuristics
-  elif [ "$PRIORITY" = "P1" ] || [ "$PRIORITY" = "P2" ]; then
+    FINDING_GENERATION=$(compute_finding_generation "$(echo "$FINDING_DATA" | jq -r '.body')")
+    FINDING_GENERATIONS[$FINDING_NUM]="$FINDING_GENERATION"
+    DEFER=true; DEFER_REASON="generation ${FINDING_GENERATION} (source #${SOURCE_NUM} is also a review-finding)"
+    if [ "$PRIORITY" = "P3" ] && [ "$FINDING_GENERATION" -le "$BATCH_MAX_GENERATION" ]; then
+      # Keep this out of individual cascade dispatch, but offer it to the P3 batching
+      # pass below. A singleton remains deferred; only a formed batch is admitted.
+      BATCHABLE_DEFERRED_P3+=("$FINDING_NUM")
+      DEFER_REASON="generation ${FINDING_GENERATION} — eligible for bounded P3 batching only"
+    fi
+   # Priority override: P0/P1 always execute; P2 is eligible for batch planning.
+   elif [ "$PRIORITY" = "P0" ] || [ "$PRIORITY" = "P1" ]; then
     DEFER=false
   # Heuristic 2: Comment/typo keyword (only applies to P3 and below)
   # Gated by CASCADE_KEYWORD_HEURISTIC (orchestration.cascade, forge#2234).
@@ -1939,6 +2502,20 @@ Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${R
     DEFER=false
   fi
 
+  [ -n "${FINDING_GENERATIONS[$FINDING_NUM]:-}" ] || FINDING_GENERATIONS[$FINDING_NUM]=1
+
+  # Opt-in only: never defer a new-surface or P1/P2 finding because another
+  # lineage is noisy. Step 4F re-evaluates this explicit deferral after drain.
+  AMPLIFICATION_RATIO=$(awk "BEGIN { if ($MERGED_UNITS) printf \"%.2f\", $FINDINGS_SPAWNED / $MERGED_UNITS; else print 0 }")
+  if [ "$DEFER" = "false" ] && [ "$FINDING_IS_REFINEMENT" = "true" ] && \
+     [ "$PRIORITY" != "P1" ] && [ "$PRIORITY" != "P2" ] && \
+     [ "$CASCADE_MAX_AMPLIFICATION" != "off" ] && \
+     awk "BEGIN { exit !($AMPLIFICATION_RATIO > $CASCADE_MAX_AMPLIFICATION) }"; then
+    DEFER=true
+    DEFER_REASON="amplification bound exceeded (same-lineage refinement; ${AMPLIFICATION_RATIO} > ${CASCADE_MAX_AMPLIFICATION})"
+    AMPLIFICATION_DEFERRED+=("$FINDING_NUM")
+  fi
+
   if [ "$DEFER" = "true" ]; then
     DEFERRED_FINDINGS+=($FINDING_NUM)
     DEFERRED_REASONS[$FINDING_NUM]="$DEFER_REASON"
@@ -1949,9 +2526,11 @@ Finding #${FINDING_NUM} has no **Code branch** annotation and its parent PR #${R
 done
 ```
 
-**Surface-area batching for queued P3 findings (MANDATORY check before dispatch):** <!-- Added: forge#1818 -->
+**Concern-level batching for queued P3 findings (MANDATORY check before dispatch):** <!-- Added: forge#1818 -->
 
-Cascade-spawned findings collected within a single `/orchestrate` run never pass back through Phase 1's batching rule — Phase 1 only runs once, at the start. Without a check here, same-file P3 findings spawned mid-run always dispatch individually, defeating the batching policy for exactly the findings it exists to catch. Apply the same grouping rule from `commands/orchestrate/phase-1-resolve.md` ("P3 Review-Finding Batching") to `QUEUED_FINDINGS` before the dispatch step below:
+Cascade-spawned findings collected within a single `/orchestrate` run must be reconsidered against the complete open, unbatched, undispatched candidate registry, not only `QUEUED_FINDINGS` from this completion cycle. At initial resolution and after every five completions (or whenever `DEFERRED_FINDINGS` reaches `MAX_CONCURRENT`), collect retained ungrouped candidates, new findings, and open batch membership; call `planP3BatchGroups()` with that registry and `batchExclusionReason()` danger-zone inputs. Execute returned `extensions` before new groups, retain `ungrouped` members for the next sweep, and record group kinds or exclusion predicates in the run summary. <!-- Added: forge#2858; extended: forge#2851, forge#2852 -->
+
+The per-cycle `QUEUED_FINDINGS` loop below remains the action-creation mechanism, but it MUST consume the complete-sweep planner output rather than decide groups from its local same-file map. Do not dispatch a locally ungrouped member until the next periodic sweep has considered it against the retained candidate set.
 
 ```bash
 # Group QUEUED_FINDINGS by exact affected file, reusing the SAME safety
@@ -1967,13 +2546,17 @@ Cascade-spawned findings collected within a single `/orchestrate` run never pass
 unset SURFACE_FILE_MEMBERS
 declare -A SURFACE_FILE_MEMBERS
 
-# Defensive cap on gh issue view fan-out. QUEUED_FINDINGS is already bounded by
+# Include generation-2 P3 findings only as batch candidates. They remain deferred
+# unless this pass actually forms a bounded batch; no member is individually queued.
+BATCHING_CANDIDATES=("${QUEUED_FINDINGS[@]}" "${BATCHABLE_DEFERRED_P3[@]}")
+
+# Defensive cap on gh issue view fan-out. BATCHING_CANDIDATES is already bounded by
 # upstream cascade control; this cap holds even if that bound is later loosened,
 # so the loop can never scale API calls linearly with cascade-seeded findings. <!-- forge#1836 -->
 MAX_BATCH_SCAN=50
 SCANNED=0
 
-for FINDING_NUM in "${QUEUED_FINDINGS[@]}"; do
+for FINDING_NUM in "${BATCHING_CANDIDATES[@]}"; do
   SCANNED=$((SCANNED + 1))
   if [ "$SCANNED" -gt "$MAX_BATCH_SCAN" ]; then
     echo "Surface-area batching: reached MAX_BATCH_SCAN=$MAX_BATCH_SCAN — remaining findings stay individually queued"
@@ -1983,7 +2566,8 @@ for FINDING_NUM in "${QUEUED_FINDINGS[@]}"; do
   FINDING_DATA=$(gh issue view $FINDING_NUM -R {GH_REPO} --json title,body,labels \
     --jq '{title: .title, body: .body, labels: [.labels[].name]}')
 
-  # Safety exclusions — never batch, at any priority. Same jq test() engine and
+  # Billing is never batched. Security findings are classified below and may
+  # batch only with their exact same class. Same jq test() engine and
   # patterns as phase-1-resolve.md's batching rule (single shared mechanism).
   # Word-boundary anchored (not bare substrings) and attribution-boilerplate
   # (**Confidence**/**Severity**/**Review comment** — see forge#2477 note below
@@ -2011,9 +2595,9 @@ for FINDING_NUM in "${QUEUED_FINDINGS[@]}"; do
   # keyword is not auto-batched) for closing a real bypass — the safe
   # direction for a security-relevant exclusion. <!-- forge#2477 -->
   echo "$FINDING_DATA" | jq -e '
-    (.title | test("\\b(security|billing|anti-bot|auth|authentication|authorization|authn|authz)\\b"; "i"))
-    or ((.body | gsub("(?m)^\\*\\*(?:Confidence\\*\\*: (?:CONFIRMED|LIKELY|POSSIBLE)|Severity\\*\\*: (?:CRITICAL|HIGH|MEDIUM|LOW|INFO)|Review comment\\*\\*: https?://\\S+)$"; "")) | test("## Problem[\\s\\S]{0,500}\\b(security|billing|anti-bot|auth|authentication|authorization|authn|authz)\\b"; "i"))
-    or ([.labels[]] | any(. == "security" or . == "billing" or . == "anti-bot" or . == "auth"))
+    (.title | test("\\b(billing|operator-only|manual action required|human action required)\\b"; "i"))
+    or ((.body | gsub("(?m)^\\*\\*(?:Confidence\\*\\*: (?:CONFIRMED|LIKELY|POSSIBLE)|Severity\\*\\*: (?:CRITICAL|HIGH|MEDIUM|LOW|INFO)|Review comment\\*\\*: https?://\\S+)$"; "")) | test("## Problem[\\s\\S]{0,500}\\b(billing|operator-only|manual action required|human action required)\\b"; "i"))
+    or ([.labels[]] | any(. == "billing" or . == "needs-human" or . == "blocked" or . == "operator-only"))
   ' >/dev/null && continue
 
   # Only P3 findings are eligible (P1/P2 already dispatched individually above).
@@ -2023,7 +2607,11 @@ for FINDING_NUM in "${QUEUED_FINDINGS[@]}"; do
   FINDING_FILE=$(echo "$FINDING_DATA" | jq -r '.body' | grep -oE '`[^`]+\.(py|tsx?|jsx?|sql|json|ya?ml|sh|md)`' | head -1 | tr -d '`')
   [ -z "$FINDING_FILE" ] && continue
 
-  SURFACE_FILE_MEMBERS["$FINDING_FILE"]="${SURFACE_FILE_MEMBERS[$FINDING_FILE]} $FINDING_NUM"
+  SAFETY_CLASS=$(node -e 'import("./bin/engine/admission.mjs").then(({ classifyBatchSafety }) => process.stdout.write(classifyBatchSafety(process.argv[1]) || "routine"))' "$(echo "$FINDING_DATA" | jq -r '.title + "\n" + .body + "\n" + (.labels | join(" "))')")
+  # Same file is not enough for security work: the class key prevents a
+  # credential finding from sharing a batch with injection/auth hardening.
+  SURFACE_KEY="${SAFETY_CLASS}:${FINDING_FILE}"
+  SURFACE_FILE_MEMBERS["$SURFACE_KEY"]="${SURFACE_FILE_MEMBERS[$SURFACE_KEY]} $FINDING_NUM"
 done
 
 # For each same-file cluster of 2+, actually CREATE the batch issue (executable —
@@ -2034,23 +2622,39 @@ for FILE in "${!SURFACE_FILE_MEMBERS[@]}"; do
   MEMBERS=(${SURFACE_FILE_MEMBERS[$FILE]})
   [ "${#MEMBERS[@]}" -ge 2 ] || continue
 
+  SAFETY_CLASS=${FILE%%:*}
+  SURFACE_FILE=${FILE#*:}
+
   # Sanitize the affected-file path before interpolating it into the issue title/body.
   # Git filenames can legally carry shell metacharacters (`$()`, backticks, quotes);
   # restrict to a validated charset so the value cannot break the gh argument
   # boundary from an untrusted issue body. Shared guard with phase-1-resolve.md. <!-- forge#1833, forge#1835 -->
-  SAFE_SURFACE_AREA=$(printf '%s' "$FILE" | tr -cd 'A-Za-z0-9._/-')
+  SAFE_SURFACE_AREA=$(printf '%s' "$SURFACE_FILE" | tr -cd 'A-Za-z0-9._/-')
 
-  echo "Same-run surface-area cluster: ${#MEMBERS[@]} P3 findings share $FILE — creating batch issue(s)"
+  echo "Same-run surface-area cluster: ${#MEMBERS[@]} ${SAFETY_CLASS} findings share $SURFACE_FILE — creating batch issue(s)"
 
-  # Cap at 8 members per batch (phase-1-resolve.md limit); split into batches of <=8.
-  for START in $(seq 0 8 $(( ${#MEMBERS[@]} - 1 ))); do
-    CHUNK=("${MEMBERS[@]:$START:8}")
+  # Routine batches cap at 8; security-class batches cap at 3 and their body
+  # must state a live-vector or defence-in-depth verdict for every member.
+  BATCH_CAP=8
+  [ "$SAFETY_CLASS" != "routine" ] && BATCH_CAP=3
+  for START in $(seq 0 "$BATCH_CAP" $(( ${#MEMBERS[@]} - 1 ))); do
+    CHUNK=("${MEMBERS[@]:$START:$BATCH_CAP}")
     [ "${#CHUNK[@]}" -ge 2 ] || continue
 
     MEMBER_LINES=""
+    BATCH_MEMBER_GENERATION=1
+    GEN2_MEMBER_LINES=""
     for M in "${CHUNK[@]}"; do
       MTITLE=$(gh issue view "$M" -R {GH_REPO} --json title --jq '.title' 2>/dev/null || echo "")
       MEMBER_LINES="${MEMBER_LINES}- [ ] #${M}: ${MTITLE}"$'\n'
+      MEMBER_GENERATION="${FINDING_GENERATIONS[$M]:-1}"
+      if [ "$MEMBER_GENERATION" -gt "$BATCH_MEMBER_GENERATION" ]; then
+        BATCH_MEMBER_GENERATION="$MEMBER_GENERATION"
+      fi
+      if [ "$MEMBER_GENERATION" -ge 2 ]; then
+        GEN2_MEMBER_LINES="${GEN2_MEMBER_LINES}- #${M}: generation ${MEMBER_GENERATION}"$'\n'
+      fi
+      [ "$SAFETY_CLASS" = "routine" ] || MEMBER_LINES="${MEMBER_LINES}  - **Verdict**: [ ] live vector  [ ] defence-in-depth"$'\n'
     done
 
     # Dedup-check with member exclusion (MANDATORY — forge#2432, identical mechanism to
@@ -2076,10 +2680,8 @@ for FILE in "${!SURFACE_FILE_MEMBERS[@]}"; do
       continue
     fi
 
-    BATCH_ISSUE_NUM=$(gh issue create {GH_FLAG} \
-      --title "$PROPOSED_BATCH_TITLE" \
-      --label "review-finding,priority:P3,batch" \
-      --body "$(cat <<BATCH_EOF
+    CREATE_TOKEN="forge-create-$(date -u +%Y%m%dT%H%M%SZ)-$$-$RANDOM"
+    CREATE_BODY="$(cat <<BATCH_EOF
 ## Problem
 
 Batch of P3 review findings in **${SAFE_SURFACE_AREA}** (same file), clustered mid-run by phase-4-execution.md to reduce per-finding pipeline overhead.
@@ -2089,6 +2691,12 @@ Batch of P3 review findings in **${SAFE_SURFACE_AREA}** (same file), clustered m
 <!-- FORGE:BATCH_MEMBERS -->
 ${MEMBER_LINES}<!-- /FORGE:BATCH_MEMBERS -->
 
+**Maximum member generation**: ${BATCH_MEMBER_GENERATION}
+<!-- FORGE:BATCH_MAX_GENERATION: ${BATCH_MEMBER_GENERATION} --> <!-- allowlist:check-spec-markers -->
+
+**Generation >= 2 members admitted by bounded batching**:
+${GEN2_MEMBER_LINES:-none}
+
 ## Acceptance Criteria
 
 - [ ] All member findings addressed or closed as false-positive
@@ -2097,7 +2705,26 @@ ${MEMBER_LINES}<!-- /FORGE:BATCH_MEMBERS -->
 
 <!-- FORGE:BATCHABLE -->
 BATCH_EOF
-)" --json number --jq '.number')
+    )"
+    CREATE_BODY="${CREATE_BODY}
+
+<!-- issue-create-token:${CREATE_TOKEN} -->"
+    CREATE_RESPONSE=$(gh api "repos/{GH_REPO}/issues" --method POST \
+      -f title="$PROPOSED_BATCH_TITLE" -f body="$CREATE_BODY" \
+      -f 'labels[]=review-finding' -f 'labels[]=priority:P3' -f 'labels[]=batch') || {
+      echo "ERROR: GitHub rejected same-run batch creation; members remain queued." >&2
+      continue
+    }
+    BATCH_ISSUE_NUM=$(echo "$CREATE_RESPONSE" | jq -r '.number // empty')
+    if [ -z "$BATCH_ISSUE_NUM" ]; then
+      echo "ERROR: same-run batch creation returned no issue number; members remain queued." >&2
+      continue
+    fi
+    CREATED_BODY=$(gh issue view "$BATCH_ISSUE_NUM" -R {GH_REPO} --json body --jq '.body') || continue
+    if ! printf '%s' "$CREATED_BODY" | grep -qF "issue-create-token:${CREATE_TOKEN}"; then
+      echo "ERROR: batch issue #${BATCH_ISSUE_NUM} failed create-token read-back; members remain queued." >&2
+      continue
+    fi
 
     # Consume the cluster: record members and REPLACE them in QUEUED_FINDINGS
     # with the single batch issue, so the dispatch step below operates on the
@@ -2596,6 +3223,8 @@ The context-gathering phase can fetch this index to discover all investigation G
 **Repository**: {GH_REPO}
 **Repo path**: {REPO_PATH}
 
+**KNOWLEDGE GIST CAPABILITY**: This orchestration already probed it: `${FORGE_GIST_CAPABLE}`. Before invoking `/work-on`, run `export FORGE_GIST_CAPABLE=${FORGE_GIST_CAPABLE}`. Do not re-probe or attempt Gist creation when it is `false`.
+
 **YOUR MISSION**: Invoke \`/work-on\` via the Skill tool and let it run to completion. \`/work-on\` is a self-contained routing loop that handles the ENTIRE pipeline: investigate → build (context → architect → implement → validate) → review (push → PR → /review-pr --auto-merge) → close (project board → trajectory log → worktree cleanup). Do NOT intervene, compensate, or manually close issues — \`/work-on\` handles everything including issue closure and label updates in its close phase.
 
 **CRITICAL — DO NOT STOP EARLY**: /work-on runs as a multi-phase routing loop. Each phase (investigate, build, review, close) returns an intermediate result — these are NOT completion signals. You are NOT done until the issue reaches a terminal state: \`workflow:merged\`, \`workflow:invalid\`, \`needs-human\`, or \`workflow:awaiting-merge\`. If /work-on returns after only one phase (e.g., investigation), you MUST invoke it again immediately — it will re-read GitHub state and continue to the next phase. Keep invoking /work-on until it reaches a terminal state. Never output 'done' or stop after an intermediate result.