resolve

<!-- oss:resolve Step 8 — executed via: cat $_OSS_RESOLVE/modes/action-item-dispatch.md; execute -->

<!-- fragment — no <workflow> wrapper; executed inline by SKILL.md -->

<!-- Input: SELECTED_ITEMS (from Step 3e), COMMIT_MODE + GROUP_STRATEGY (from Step 3d), CODEX_AVAILABLE (from Step 1), PR_REF (from Step 4), $_OSS_RESOLVE, ARGUMENTS -->

<!-- Output: items implemented/staged/committed; CHALLENGE_LOG populated; CHANGE_SCOPE set for Step 9 -->

## Step 8: Implement action items

**Commit authorization — entire Step 8**: `COMMIT_MODE` from Step 3d governs all commits; never re-ask regardless of mode, item count, or sentinel state. Multiple resolve flows per session each honor own Step 3d choice.

Determine implementation agent, set up file-handoff dir, and authorize commits before the loop:

`IMPL_AGENT`'s default is a routing marker, not a value passed to `Agent(subagent_type=)`. It records that unrouted work belongs to the bridge, and is read by the C1 medium-effort shortcut (which dispatches `Skill(skill="bridge:implement")`) and by the >8-item batching gate in `SKILL.md`. Phase 2 never uses it: it groups by the `change` → specialist table below, whose values are all real subagent types. Only `--agent <name>` puts a caller-supplied value in this variable, and that value does reach `Agent(subagent_type=)`.

Substitute the Step 3e selection into `SELECTED_ITEMS` below as space-separated ids. It is orchestrator-held state, so this block is the only place it enters the shell; every later block reads the file this one writes.

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
eval "$(python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/parse-skill-flags.py" --flags worktree --value-flags agent "$ARGUMENTS")"  # timeout: 5000
IMPL_AGENT="${VALUE_AGENT:-bridge:implement}"
[ -n "$VALUE_AGENT" ] && echo "→ Using --agent: $IMPL_AGENT"

# IMPL_DIR sentinel written at mktemp time in pr-intelligence.md — re-read here, never re-create
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -z "$IMPL_DIR" ] && { IMPL_DIR=$(mktemp -d); echo "$IMPL_DIR" > "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}"; }  # timeout: 3000 — report-mode has no Step 3b
mkdir -p "$IMPL_DIR"  # timeout: 3000
SELECTED_ITEMS="<space-separated selected ids>"
case "$SELECTED_ITEMS" in *'<'*'>'*|"") echo "! BLOCKED — SELECTED_ITEMS still holds the placeholder; substitute the Step 3d ids before running this block"; exit 1 ;; esac
case "$SELECTED_ITEMS" in *[!0-9\ ]*) echo "! BLOCKED — SELECTED_ITEMS must be space-separated digits only, got: $SELECTED_ITEMS"; exit 1 ;; esac
printf '%s\n' "$SELECTED_ITEMS" > "$IMPL_DIR/selected-items.txt"
CHALLENGE_LOG="$IMPL_DIR/challenge-log.txt"; : > "$CHALLENGE_LOG"  # one record per line: id=… resolution=… evidence=… suggestion=… finding=… evidence_why=… suggestion_why=… detail=… — resolution right after id, before any free-text field, so a reviewer's quoted text can never be mistaken for it (every consumer greps this by field name, never by position, so the order itself carries no other meaning); file, not shell array: survives compaction + separate Bash calls, Step 11 renders from it
: > "$IMPL_DIR/skipped-items.txt"  # item_id<TAB>reason, one per line — Phase 2 appends (fenced block below), Phase 3 close-out consumes; initialized empty so a no-skip run still has a readable file
: > "$IMPL_DIR/phase2-commits.jsonl"  # one JSON object per line: {"item_id","sha","group"} — Phase 2 appends per group (fenced block below), Phase 3's build_merge_plan.py producer consumes; initialized empty so an all-C1/all-rejected run still has a readable file
: > "$IMPL_DIR/c1-deferred-files.txt"  # one file path per line — C1 fence appends for non-each COMMIT_MODE (fenced block below), Phase 3's clean-run staging fence consumes; initialized empty so a run with no C1 items (or CODEX_AVAILABLE=false) still has a readable file
: > "$IMPL_DIR/specialist-worktrees.txt"  # one absolute path per line — Phase 2 appends per group (fenced block below), Phase 3's cleanup loop consumes; initialized empty so an all-C1/all-rejected run (no Phase 2 dispatch) still has a readable file
: > "$IMPL_DIR/c1-item-summary.tsv"  # item_id<TAB>summary, one per line — C1 fence appends per DONE item; grouped-commit fence (Site 5) reads it for C1 items with no phase2-commits.jsonl row
: > "$IMPL_DIR/c1-item-files.tsv"  # item_id<TAB>path, one per line — C1 fence appends per DONE item's files_changed; same consumer as above, kept separate from c1-deferred-files.txt (bare-path shape two other consumers already depend on)
```

**Concurrency guard — mutex + HEAD fingerprint** (Phase 2 holds worktrees open for the slowest specialist's whole runtime — minutes — so an external write to the branch, or a second resolve run, is far likelier to land mid-flight than under the old per-item design). The lock path is deterministic (recompute anytime from the git-common-dir + branch); the base SHA is a point-in-time value, so persist it to a tmpfile — shell vars don't survive between Step 8's separate bash calls:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-pr-ref-${CSID}" ] && IFS= read -r PR_REF < "${TMPDIR:-/tmp}/resolve-pr-ref-${CSID}" || PR_REF="#${PR_NUMBER:-0}"  # set in Step 4 — #<N> same-repo, full PR_URL when committing to a fork
_GITDIR=$(git rev-parse --git-common-dir 2>/dev/null || echo ".git")  # timeout: 3000
_BRANCH=$(git branch --show-current 2>/dev/null | tr '/' '-' || echo "detached")  # timeout: 3000
RESOLVE_LOCK="$_GITDIR/oss-resolve-${_BRANCH}.lock"  # shared across worktrees (git-common-dir)
python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/heal_git_artifacts.py" locks --pattern 'oss-resolve-*.lock' --apply  # timeout: 30000
if [ -f "$RESOLVE_LOCK" ]; then
    echo "⛔ another oss:resolve is active on branch '$_BRANCH' (lock: $RESOLVE_LOCK) — aborting."
    echo "  Healer kept it: holder PID is alive and the lock is under the age cap. Wait, or delete it if you know that run died."
    exit 1
fi
echo "$PPID $(date -u +%FT%TZ)" > "$RESOLVE_LOCK"  # PPID not $$ — $$ is a fresh shell per Bash call, dead before the next one reads it  # timeout: 3000
git rev-parse HEAD > "${TMPDIR:-/tmp}/resolve-base-sha-${CSID}" 2>/dev/null || true  # HEAD fingerprint  # timeout: 3000
```

Lock released in Phase 3's cleanup block. Crash before that leaks it — by design: no `trap` can release it, since trap disposition is per-process and dies with the Bash call that registers it (`research:fortify` documents the same constraint). The healer is the recovery path: it reclaims a lock whose holder PID is provably dead immediately, and any lock past the 30-min age cap regardless. It sweeps **every** `oss-resolve-*.lock` in the common dir, not just this branch's — a leak on a branch never resolved again is otherwise never revisited and survives indefinitely (observed: 27 days).

**Reclaiming here is automatic but never silent** — print the healer's output verbatim whenever it reclaimed anything, naming each lock and why (dead holder / age). No approval gate: a lock file with a provably dead holder carries no user work, and this replaces an override that already fired unattended at 30 minutes. Worktree healing is the opposite case and does gate on approval — see `worktree-isolation.md`.

`change` → `IMPL_AGENT` routing table — drives Phase 2 specialist grouping **unconditionally** (not gated behind `CODEX_AVAILABLE`; Codex only ever handles items via the C1 medium-effort shortcut below, never as a Phase 2 specialist group). Keep in sync with `_shared/review-section-taxonomy.md`'s resolve `change` column:

| `change` value | `IMPL_AGENT` |
| -- | -- |
| `code` · `refactor` · `config` · `ci` | `foundry:sw-engineer` |
| `test` | `foundry:qa-specialist` |
| `docs` | `foundry:doc-scribe` |
| `style` | `foundry:linting-expert` |
| `perf` | `foundry:perf-optimizer` |
| `architecture` | `foundry:solution-architect` |

`CODEX_AVAILABLE=false`: C1 (medium-effort Codex shortcut, below) is skipped entirely — medium-effort items fall through to Phase 1+2 like any other item, routed by this same table. `xhigh`-effort, multi-file items still skip (`⚠ bridge@borda-ai-rig is absent or disabled — skipping item #<id> (xhigh effort)`) — too much surface for a single specialist without the bridge's broader Codex context; never blanket-skip anything below `xhigh`.

`--agent <name>` overrides this routing table unconditionally — every Phase 2 group uses `<name>` regardless of `change`.

> **Conflict gate**: verify all Step 5a conflict tasks `completed` before any action item. Still `pending`/`in_progress` → stop, surface list, wait. Items on unresolved conflicts compound diff.

Process items in `SELECTED_ITEMS` (from Step 3e) in priority order (`[req]` first, then `[suggest]`).

**Codex effort classification** — classify each item before dispatch; set `ITEM_EFFORT`; aggregate to `CHANGE_SCOPE` for Step 9:

- typo/spelling/whitespace/formatting/comment/rename-single/docstring → `medium`; multi-file/refactor/architecture/new-feature/redesign → `xhigh`; all else → `high` (default)
- Minimum effort is always `medium` — never `low`
- `ITEM_EFFORT` set per item; include in agent prompt as `"Effort level: $ITEM_EFFORT.\n..."` prefix
- `CHANGE_SCOPE` = aggregate across all `SELECTED_ITEMS`:
  - ALL items classified `medium` → `CHANGE_SCOPE=lint-only`
  - ANY item classified `xhigh` → `CHANGE_SCOPE=full`
  - otherwise → `CHANGE_SCOPE=targeted` (default)
- Compute `CHANGE_SCOPE` once before the loop; pass to Step 9 via shell variable

**Caps** — soft cap 10, hard cap 20 items per dispatch. When `SELECTED_ITEMS` > 10 (count from context, or `wc -w < "$IMPL_DIR/selected-items.txt"` after re-reading `IMPL_DIR` from its sentinel): invoke `AskUserQuestion` — (a) Apply first 10 now, re-run for remainder · (b) Apply all `[req]` only · (c) Proceed with all up to 20 (slow, context risk). Never silently start loop with >10 items; never exceed 20 in one dispatch (context budget boundary).

**Parallel specialist-worktree dispatch** (replaces sequential/one-item-at-a-time execution — real wall-clock lever, not just spawn-count reduction): C1 Codex-first routing (below) still runs first — batched ≤3 disjoint-file items per call, same-file items sequential. Everything falling through C1 splits into three passes: **Phase 1** challenge (read-only, parallel by domain), **Phase 2** implementation (one isolated `git worktree` per specialist, parallel), **Phase 3** merge-back (sequential, orchestrator-owned cherry-pick in original priority order). See Phase 1/2/3 below.

**Per action item** — loop over `SELECTED_ITEMS` in priority order. Per item, read full details from `$IMPL_DIR/action-items.jsonl` (written by Step 3b pr-intelligence subagent) — this is the authoritative source for `full_comment_text`, `file`, `line`, `change`, `severity`, `author`:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
_ID="<id>"
case "$_ID" in ''|*[!0-9]*) echo "! BLOCKED — item id placeholder not substituted or non-numeric"; exit 1 ;; esac
ITEM_DATA=$(jq -c ". | select(.id == $_ID)" "$IMPL_DIR/action-items.jsonl")  # timeout: 5000
```

Use `.full_comment_text` for `IMPL_PROMPT`, `.file`/`.line` for commit scope and blast-radius lookup, `.change`/`.severity` for effort classification and agent routing.

**Pre-loop blast-radius scan** — run once in main orchestrator before loop starts; collect caller context per item so each impl subagent knows which contracts to preserve. Soft: missing `codemap-py query` is a no-op.

Group selected items by canonical module before querying: one `rdeps` answer per module per pre-loop, shared with every matching item. Read the **review pre-flight cache** first (materialized in SKILL.md Step 8; contract in `$_DEV_SHARED/codemap-context.md` §Review→resolve pre-flight cache). `codemap_cache.py read` validates index freshness; reuse requires an actual `rdeps` answer, including a valid empty caller list. Cache miss → one live query. Never use empty rendered text as a cache-miss signal. Reused hits retain their `delta.notes` marker for the existing health report.

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""  # prelude's mktemp path
[ -f "$IMPL_DIR/selected-items.txt" ] && IFS= read -r SELECTED_ITEMS < "$IMPL_DIR/selected-items.txt" || SELECTED_ITEMS=""
# pre-loop; BLAST_RADIUS_CONTEXT shared with impl agents
BLAST_RADIUS_CONTEXT=""
[ -f "${TMPDIR:-/tmp}/resolve-codemap-cache-dir-${CSID}" ] && IFS= read -r CODEMAP_CACHE_DIR < "${TMPDIR:-/tmp}/resolve-codemap-cache-dir-${CSID}" || CODEMAP_CACHE_DIR=""  # timeout: 3000
# index dir anchors at git root, not cwd; raw basename, no `tr -cd` — the scanner writes the name unsanitized, so stripping would seek a file it never wrote
_ROOT=$(git rev-parse --show-toplevel 2>/dev/null); [ -n "$_ROOT" ] || _ROOT="$PWD"
_IDX_FILE="${CODEMAP_INDEX_DIR:-$_ROOT/.cache/codemap}/$(basename "$_ROOT").json"
_CACHE_BIN="${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/codemap_cache.py"
if command -v codemap-py >/dev/null 2>&1 && [ -f "$IMPL_DIR/action-items.jsonl" ]; then
    echo "→ Codemap pre-scan — caller context for selected action items:"
    # file→module from the index's own `name` field (same source as §Structural prep, and as the cache keys). A sed transform names pkg/__init__.py `pkg.__init__` while codemap calls it `pkg` — every package-init item then missed its cache entry AND errored on the live query.
    _MODMAP="$IMPL_DIR/codemap-maps.json"
    _MAP_STAMP=$(python -c 'import pathlib,sys; p=pathlib.Path(sys.argv[1]); s=p.stat(); sys.stdout.write(f"{p.resolve().as_posix()}:{s.st_size}:{s.st_mtime_ns}")' "$_IDX_FILE" 2>/dev/null)
    # Native Windows jq must emit LF: CR would become part of shell IDs, paths, and module names.
    _ALL_PY=$(jq -b -r '.file // empty' "$IMPL_DIR/action-items.jsonl" | grep '\.py$' | paste -sd, -)  # timeout: 5000
    codemap-py query --timeout 15 central --top 100000 2>/dev/null \
        | python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/resolve_centrality.py" --files "$_ALL_PY" > "$_MODMAP" 2>/dev/null || : > "$_MODMAP"  # timeout: 20000
    printf '%s\n' "$_MAP_STAMP" > "$IMPL_DIR/codemap-maps.stamp"
    _MODULE_ITEMS=$(jq -s --arg ids "$SELECTED_ITEMS" --slurpfile maps "$_MODMAP" '
        ($ids | split(" ")) as $selected |
        map(select((.id | tostring) as $id | $selected | index($id))) |
        map(. + {module: ($maps[0].file_module[.file] // "")}) |
        map(select(.module != "")) | group_by(.module) |
        map({key: .[0].module, value: map(.id)}) | from_entries
    ' "$IMPL_DIR/action-items.jsonl" 2>/dev/null)
    for _m in $(printf '%s' "$_MODULE_ITEMS" | jq -b -r 'keys[]'); do
        _c=""
        _CACHE_HIT=false
        # cache-first: reuse review's rdeps answer when fresh; only query on miss
        if [ -n "$CODEMAP_CACHE_DIR" ] && [ -f "$_CACHE_BIN" ] && [ -f "$_IDX_FILE" ]; then
            _V=$(python "$_CACHE_BIN" read --module "$_m" --index "$_IDX_FILE" --cache-dir "$CODEMAP_CACHE_DIR" 2>/dev/null)  # timeout: 5000
            if printf '%s' "$_V" | jq -e --arg module "$_m" '
                .reuse == true and (.answers.rdeps | type == "object") and
                (.answers.rdeps.module == $module) and (.answers.rdeps.imported_by | type == "array") and
                (.answers.rdeps.error == null) and
                (.answers.rdeps.index | type == "object") and
                (.answers.rdeps.index | if has("query_complete") then .query_complete == true else .exhaustive == true end) and
                ([.answers.rdeps, .answers.rdeps.index // {}] | all(
                    .stale != true and .root_mismatch != true and .truncated != true
                ))
            ' >/dev/null 2>&1; then
                _CACHE_HIT=true
                _c=$(printf '%s' "$_V" | python -c "import json,sys; print(json.dumps(json.load(sys.stdin)['answers']['rdeps']))")
                _ART="$CODEMAP_CACHE_DIR/${_m}.json"
                [ -f "$_ART" ] && python -c "import json,sys; p=sys.argv[1]; d=json.load(open(p)); d['delta']['notes'].append('reused'); json.dump(d,open(p,'w'))" "$_ART" 2>/dev/null || true
            fi
        fi
        [ "$_CACHE_HIT" = true ] || _c=$(codemap-py query rdeps "$_m" 2>/dev/null)  # timeout: 10000
        if [ -n "$_c" ]; then
            for _id in $(printf '%s' "$_MODULE_ITEMS" | jq -b -r --arg module "$_m" '.[$module][]'); do
                printf "  #%s %s ← callers: %s\n" "$_id" "$_m" "$(echo "$_c" | tr '\n' ' ')"
                BLAST_RADIUS_CONTEXT+="item #${_id} (${_m}) callers:"$'\n'"${_c}"$'\n\n'
            done
        fi
    done
    [ -z "$BLAST_RADIUS_CONTEXT" ] && echo "  (no Python callers found for selected items)"
    # health metric — reuse_ratio over the materialized cache
    [ -n "$CODEMAP_CACHE_DIR" ] && [ -f "$_CACHE_BIN" ] && python "$_CACHE_BIN" report --cache-dir "$CODEMAP_CACHE_DIR" 2>/dev/null || true  # timeout: 5000
fi
```

Per item before impl dispatch, extract this item's caller section:

```bash
item_id=$_id  # align with blast-radius scan loop variable
ITEM_CALLERS=$(awk "/^item #${item_id} /,/^[[:space:]]*$/" <<< "$BLAST_RADIUS_CONTEXT" | tail -n +2)
```

Include non-empty `$ITEM_CALLERS` in impl agent prompt — see Phase 2.

**C1 — Codex-first routing for `medium` effort items** (skip Phase 1+2 when Codex handles it):

When `ITEM_EFFORT=medium` AND `CODEX_AVAILABLE=true`: dispatch Codex for evidence check + implementation. **Batch disjoint-file items** — collect all C1-eligible items first, group ≤3 per call with pairwise-distinct `file` values (two items on the SAME file always go in separate calls — a shared-file batch makes the per-item diff inseparable, breaking one-commit-per-item and per-item CHALLENGE_LOG attribution). Each blocking round-trip then covers up to 3 items instead of 1.

**SECURITY — never type a review comment into `args=` inline.** The comment text is untrusted external content; `bridge:implement`'s own contract requires routing text you did not author through a scratch file plus `--task-file`, never inline `--task`. Build the static wrapper with `printf` (no untrusted content in it), append each item's line via a separate `jq` extraction from `action-items.jsonl` — never hand-typed — then dispatch with `--task-file`:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -n "$IMPL_DIR" ] || { echo "! BLOCKED — IMPL_DIR sentinel missing; prelude never ran"; exit 1; }
_BATCH_TAG="<this batch's first item id>"
case "$_BATCH_TAG" in ''|*[!0-9]*) echo "! BLOCKED — C1 batch tag placeholder not substituted or non-numeric"; exit 1 ;; esac
_BRIEF="$IMPL_DIR/c1-brief-${_BATCH_TAG}.md"
printf '%s\n' \
    "Effort level: medium. Review each action item independently and implement it if valid." \
    "Items touch disjoint files — never edit one item's file for another item." \
    "" > "$_BRIEF"
for _bid in <space-separated item ids in this batch, up to 3>; do
    case "$_bid" in ''|*[!0-9]*) echo "! BLOCKED — batch item id not numeric: $_bid"; exit 1 ;; esac
    _LINE=$(jq -r --arg id "$_bid" 'select((.id|tostring)==$id) | "Item \(.id): \(.full_comment_text)  File: \(.file)  Line: \(.line)"' "$IMPL_DIR/action-items.jsonl")
    [ -n "$_LINE" ] || { echo "! BLOCKED — item $_bid not found in action-items.jsonl"; exit 1; }
    printf '%s\n' "$_LINE" >> "$_BRIEF"
done
printf '%s\n' \
    "" \
    "Each reviewer assertion is itself an unproven claim — if it asserts a fact the file alone can't settle" \
    "(name/identifier/version/count wrong or non-standard), verify against the actual authoritative source" \
    "before treating it as valid; can't verify → UNCERTAIN, not DONE. Verdicts are per item — one UNCERTAIN" \
    "never blocks another item's DONE." \
    "Return ONLY compact JSON array as your FINAL message, one element per item:" \
    '[{"id":<id>,"verdict":"DONE"|"UNCERTAIN","reason":"<one sentence>","files_changed":["<path>", ...]}, ...]' \
    >> "$_BRIEF"
```

Immediately after this Skill call returns, persist its raw JSON array reply verbatim via the Write tool to `$IMPL_DIR/c1-reply-<batch_tag>.json` (same `<batch_tag>` as `_BATCH_TAG` above) — the commit fence and challenge-log append below both read it via `jq`, never by re-typing the reply's contents:

```text
Skill(skill="bridge:implement", args="--task-file <substitute the absolute path written to _BRIEF above> --effort medium")
```

Parse the JSON array — per element, in item priority order:

- **DONE** → mark item resolved; commit/stage that item's `files_changed` using the fence below (per-item commit stays granular — the disjoint-file grouping guarantees the diff separates); append to `CHALLENGE_LOG` using the shared append block (§Challenge-log append below) with `_RESOLUTION=codex-direct` and `_DOMAIN=<batch_tag>` — that block extracts `finding=`/`evidence_why=`/`suggestion_why=`/`detail=` from the persisted `c1-reply-<batch_tag>.json` via `jq`, never by retyping the reviewer's text; skip Phase 1+2 for that item
- **UNCERTAIN** → that item falls through to Phase 1+2 (normal challenge + implementation flow)
- element missing for a dispatched item → treat as UNCERTAIN, never silently resolved

**Only `each` mode commits here.** `git add`-ing a C1 item's files before Phase 3 runs — even a `stage`/`grouped`/`all` item, even touching a file no Phase 2 item touches — leaves the index non-clean, and Phase 3's `merge_specialist_batch.py` cherry-picks refuse to run against a non-clean index (confirmed empirically: `git cherry-pick` exits 128, "your local changes would be overwritten", before it even reaches the merge). An **unstaged** working-tree edit does not trigger that refusal — **only when the C1 item's file is disjoint from every Phase 2 item's file**; an unstaged edit on a file a Phase 2 cherry-pick also touches reproduces the identical refusal (empty file list, no `CHERRY_PICK_HEAD`, no recovery route), confirmed empirically. C1 is invisible to Phase 2's file-ownership tiebreak (it skips Phase 1/2 entirely, so nothing else in the file compares a C1 item's file against a Phase 2 item's) — the merge fence's own guard right before it calls `merge_specialist_batch.py` is what actually catches this overlap; it is what makes deferring here safe, not the unstaged/staged distinction alone. So `stage`/`grouped`/`all` C1 items are left as plain unstaged edits here and only `git add`ed after Phase 3 returns clean (see the fence right after the `merge_specialist_batch.py` call below):

**SECURITY — every field below comes from `jq`-extracting `action-items.jsonl`/`c1-reply-<batch_tag>.json`, never from the orchestrator retyping the reviewer's comment or Codex's reply text.** `$(jq ...)` captures a command's stdout as opaque data — bash never re-parses that value for further expansion — so this is safe regardless of what characters the source text contains; the vulnerability existed only when the untrusted text was typed as literal source in a quoted string, which this block never does:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -n "$IMPL_DIR" ] || { echo "! BLOCKED — IMPL_DIR sentinel missing; prelude never ran"; exit 1; }
[ -f "${TMPDIR:-/tmp}/resolve-pr-ref-${CSID}" ] && IFS= read -r PR_REF < "${TMPDIR:-/tmp}/resolve-pr-ref-${CSID}" || PR_REF="#${PR_NUMBER:-0}"
[ -f "${TMPDIR:-/tmp}/resolve-commit-mode-${CSID}" ] && IFS= read -r COMMIT_MODE < "${TMPDIR:-/tmp}/resolve-commit-mode-${CSID}" || COMMIT_MODE="unset"
_BATCH_TAG="<this batch's first item id — same value used for the brief file above>"
case "$_BATCH_TAG" in ''|*[!0-9]*) echo "! BLOCKED — C1 batch tag placeholder not substituted or non-numeric"; exit 1 ;; esac
_C1_FILE="$IMPL_DIR/c1-reply-${_BATCH_TAG}.json"
[ -s "$_C1_FILE" ] || { echo "! BLOCKED — $_C1_FILE missing/empty; persist the Codex batch reply via the Write tool before running this block"; exit 1; }
jq -e . "$_C1_FILE" >/dev/null 2>&1 || { echo "! BLOCKED — $_C1_FILE is not valid JSON"; exit 1; }
while IFS= read -r _ID; do
    case "$_ID" in ''|*[!0-9]*) echo "! BLOCKED — non-numeric id in $_C1_FILE"; exit 1 ;; esac
    _ITEM_DATA=$(jq -c ". | select(.id == $_ID)" "$IMPL_DIR/action-items.jsonl")
    [ -n "$_ITEM_DATA" ] || { echo "! BLOCKED — item $_ID not found in action-items.jsonl"; exit 1; }
    _AUTHOR=$(printf '%s' "$_ITEM_DATA" | jq -r '.author')
    _COMMENT=$(printf '%s' "$_ITEM_DATA" | jq -r '.full_comment_text')
    [ -n "$_COMMENT" ] || { echo "! BLOCKED — item $_ID has empty full_comment_text"; exit 1; }
    _ENTRY=$(jq -c --arg id "$_ID" '.[] | select((.id|tostring)==$id)' "$_C1_FILE")
    [ -n "$_ENTRY" ] || { echo "! BLOCKED — item $_ID not present in $_C1_FILE"; exit 1; }
    _SUMMARY=$(printf '%s' "$_ENTRY" | jq -r '(.reason // "") | gsub("[\n\t]"; " ")')
    [ -n "$_SUMMARY" ] || _SUMMARY="resolve review item $_ID"
    printf '%s\t%s\n' "$_ID" "$_SUMMARY" >> "$IMPL_DIR/c1-item-summary.tsv"
    _FILES=()
    while IFS= read -r _f; do [ -n "$_f" ] && _FILES+=("$_f"); done < <(printf '%s' "$_ENTRY" | jq -r '.files_changed[]?')
    [ "${#_FILES[@]}" -gt 0 ] || { echo "! BLOCKED — no files_changed for item $_ID in $_C1_FILE"; exit 1; }
    for _f in "${_FILES[@]}"; do printf '%s\t%s\n' "$_ID" "$_f" >> "$IMPL_DIR/c1-item-files.tsv"; done
    if [ "$COMMIT_MODE" = "each" ]; then
        python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/commit_action_item.py" --build --summary "$_SUMMARY" \
            --item-id "$_ID" --author "$_AUTHOR" --pr "$PR_REF" --comment "$_COMMENT" \
            --challenge "evidence=VALID suggestion=VALID resolution=codex-direct" \
            --files "${_FILES[@]}"  # timeout: 10000
    else
        printf '%s\n' "${_FILES[@]}" >> "$IMPL_DIR/c1-deferred-files.txt"  # not git-added yet — see note above; array form (not unquoted $_FILES) keeps a path containing a space on one line
    fi
done < <(jq -r '.[] | select(.verdict=="DONE") | .id' "$_C1_FILE")
```

`c1-item-summary.tsv`/`c1-item-files.tsv` (`item_id<TAB>value`, one row per item/file) are read by the grouped-commit fence (§Site 5 below) to cover C1 items that never reach `phase2-commits.jsonl` — separate files from `c1-deferred-files.txt`, whose bare-path shape two existing consumers (the clean-run staging fence and the overlap guard's Python) already depend on unchanged.

When `CODEX_AVAILABLE=false` OR `ITEM_EFFORT!=medium`: skip Codex routing; use Phase 1+2 directly.

> **Agent budget** — Phase 1's domain grouping is roster-bounded (3 challenger types, always ≤3 spawns); `comment-dispatch` batches at `BATCH_SIZE`. Phase 2's sub-group splitting is not roster-bounded the same way — see its own §Spawn wave cap below. What always applies regardless of grouping: each spawn costs ~120,851 tok of fixed overhead (~73 tool-calls' worth) plus ~12.0 s/call. **Work under ~73 calls total is cheaper inline — spawn nothing**, the common case for a 1–3 item PR. Merge a single-item group into the nearest domain rather than giving it its own agent. Keep each agent near ~55 tool-calls; past ~60 they stall without returning an envelope, forcing reconstruction from disk — so every spawn prompt must require an envelope even on exhaustion (`partial: true` plus the items finished).

### Phase 1: Challenge — parallel by domain (skip when `--no-challenge`)

Read the flag from its sentinel, not from the raw argument blob — SKILL.md Step 1 strips every flag token before mode parsing, so `$ARGUMENTS` no longer carries it here:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-no-challenge-${CSID}" ] && IFS= read -r NO_CHALLENGE < "${TMPDIR:-/tmp}/resolve-no-challenge-${CSID}" || NO_CHALLENGE="false"
echo "NO_CHALLENGE=$NO_CHALLENGE"  # timeout: 3000
```

`true` → skip this phase entirely; `SURVIVING_ITEMS` = all `SELECTED_ITEMS`, every item treated `VALID`, Challenge Log section omitted from the report. Otherwise route by domain to foreground challenge agent:

| Item domain | Challenger |
| -- | -- |
| Architecture, API design, coupling | `foundry:challenger` |
| Code logic, correctness, edge cases | `foundry:sw-engineer` |
| Test coverage, assertions, regressions | `foundry:qa-specialist` |
| Default / unclassified | `foundry:challenger` |

Set `DOMAIN_CHALLENGER` from routing table: architecture/API/coupling/default → `foundry:challenger`; code logic/correctness/edge-cases → `foundry:sw-engineer`; test coverage/assertions/regressions → `foundry:qa-specialist`. Use agent-resolution.md fallback if foundry absent.

Group items by `DOMAIN_CHALLENGER`, preserving each item's original priority-order position within its group (stable partition — needed later so Phase 3's merge plan also respects each specialist's internal commit order). One combined challenge call per domain group, covering ALL that group's items. Derive `<domain>` per group as a short kebab-case slug from the group's shared theme (e.g. `logic`, `tests`, `docs-api`) — the delta between groups, reused as `name="challenge-<domain>"`, as the prompt lead, and as the output filename suffix. `description` = 3–5 words naming that group's theme, never echoing `name` or the shared PR. Compose every group's labels in one pass and confirm the prompt leads differ in their first word — FleetView prints `name` plus the leading chars of prompt line 1, so a shared prefix there yields indistinguishable rows (task-lifecycle.md §Spawn slots):

```text
Agent(subagent_type="${DOMAIN_CHALLENGER}", prompt="<domain>: two-part challenge for these review items.
Part 1 — for each, does the stated problem exist in the code as described?
The reviewer's assertion is itself an unproven claim, not evidence — 'reads like X' != 'is X'.
When a finding asserts a fact reading the referenced file alone can't settle (a name/identifier/version/count is wrong, non-standard, or inconsistent — license names, API/symbol names, version numbers, spec IDs), verify it via WebFetch/WebSearch against the actual authoritative source for that claim (the specific project/library/spec it names — not a generic registry) before ruling VALID. Source unreachable or inconclusive → REJECT with evidence_rationale stating what couldn't be verified; never default VALID on the reviewer's word alone.
Part 2 — if problem exists, is the suggested fix the right approach?
Read each referenced file at <file:line>. Max 4 tool calls per item (the 4th reserved for one WebFetch/WebSearch when a claim needs external verification).
Items:
<id>: <full_comment_text> (<file>:<line>)
...
Write full analysis to $IMPL_DIR/challenge-domain-<domain>.md using the Write tool.
Return ONLY compact JSON as your FINAL message (nothing after it):
{\"items\":[{\"id\":N,\"evidence\":\"VALID\"|\"REJECT\",\"evidence_rationale\":\"<one sentence>\",\"suggestion\":\"VALID\"|\"REJECT\",\"suggestion_rationale\":\"<one sentence>\",\"alternative\":\"<brief alternative or null>\"}]}")
```

**Fire every domain group's `Agent()` call in the same response turn** — read-only (no working-tree writes), safe to run concurrently regardless of file overlap between domains.

Immediately after each call returns, persist its raw JSON reply verbatim via the Write tool to `$IMPL_DIR/challenge-verdicts-<domain>.json` (same `<domain>` slug as the spawn) — the verdict-processing and challenge-log append steps below both read it via `jq`, never by re-typing the reply's rationale/alternative text.

**Structural prep — fire in this same turn, concurrently with the challenge agents** (the codemap queries below are read-only and depend only on item *files*, known from Step 3b — not on any challenge verdict — so they run under the challenge agents' latency shadow, adding ~0 wall-clock; grouping in Phase 2 then finds its maps already warm). Keyed off all `SELECTED_ITEMS` (not yet-unknown `SURVIVING_ITEMS`) — a few queries for items challenge later drops are cheap and hidden under the agent latency; Phase 2 filters to survivors. Resolve each file to its canonical module name + build the whole-repo centrality map (`resolve_centrality.py`), then capture each module's **forward imports** (`deps`, fan-*out*, naturally small — never the 20-cap that truncates reverse `rdeps`):

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -f "$IMPL_DIR/selected-items.txt" ] && IFS= read -r SELECTED_ITEMS < "$IMPL_DIR/selected-items.txt" || SELECTED_ITEMS=""
CODEMAP_MAPS="$IMPL_DIR/codemap-maps.json"
DEPS_MAP="$IMPL_DIR/codemap-deps.jsonl"; : > "$DEPS_MAP"
if command -v codemap-py >/dev/null 2>&1 && [ -f "$IMPL_DIR/action-items.jsonl" ]; then
    _FILES=$(for _id in $(printf '%s\n' "$SELECTED_ITEMS"); do  # cmd-substitution splits in both shells — bare `$VAR` is a silent 1-iteration no-op under zsh
        jq -b -r "select(.id == $_id) | .file // empty" "$IMPL_DIR/action-items.jsonl"
    done | paste -sd, -)  # timeout: 5000
    _ROOT=$(git rev-parse --show-toplevel 2>/dev/null); [ -n "$_ROOT" ] || _ROOT="$PWD"
    _IDX_FILE="${CODEMAP_INDEX_DIR:-$_ROOT/.cache/codemap}/$(basename "$_ROOT").json"
    _MAP_STAMP=$(python -c 'import pathlib,sys; p=pathlib.Path(sys.argv[1]); s=p.stat(); sys.stdout.write(f"{p.resolve().as_posix()}:{s.st_size}:{s.st_mtime_ns}")' "$_IDX_FILE" 2>/dev/null)
    _SAVED_STAMP=""
    [ -f "$IMPL_DIR/codemap-maps.stamp" ] && IFS= read -r _SAVED_STAMP < "$IMPL_DIR/codemap-maps.stamp"
    if [ -z "$_MAP_STAMP" ] || [ "$_MAP_STAMP" != "$_SAVED_STAMP" ] || ! python -c 'import json,sys; d=json.load(open(sys.argv[1])); sys.exit(not set(filter(None,sys.argv[2].split(","))).issubset(d["file_module"]))' "$CODEMAP_MAPS" "$_FILES" 2>/dev/null; then
        codemap-py query central --top 100000 2>/dev/null \
            | python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/resolve_centrality.py" --files "$_FILES" > "$CODEMAP_MAPS" 2>/dev/null \
            || : > "$CODEMAP_MAPS"
        printf '%s\n' "$_MAP_STAMP" > "$IMPL_DIR/codemap-maps.stamp"
    fi
    if [ -s "$CODEMAP_MAPS" ]; then
        for _m in $(python -c 'import json,sys; sys.stdout.write(" ".join(sorted({v for v in json.load(open(sys.argv[1]))["file_module"].values() if v})))' "$CODEMAP_MAPS"); do
            codemap-py query deps "$_m" 2>/dev/null \
                | python -c 'import json,sys; d=json.load(sys.stdin); print(json.dumps({d["module"]: d.get("direct_imports", [])}))' >> "$DEPS_MAP"  # timeout: 5000
        done
    fi
fi
```

Parse each group's per-item verdict array — same granularity as a single-item challenge, never relaxed by grouping:

- Missing item id, or a present element with empty/null `evidence_rationale` or `suggestion_rationale` → treat as UNCERTAIN. Re-dispatch it alone (single-item challenge call, same domain); persist that reply via the Write tool to a **separate** file, `$IMPL_DIR/challenge-verdicts-<domain>-retry-<id>.json` — never overwrite the group's own `challenge-verdicts-<domain>.json`, which still holds every sibling item's verdict this pass hasn't appended yet. The append block below prefers the retry file for that id when present, and its `// "challenge agent returned no rationale after retry"` fallback covers the still-empty case exactly once, after the real retry — never before it.
- `evidence=REJECT` → print `⊘ #<id> evidence rejected: <reason from the persisted verdict file>`; set type `[challenged:reject]`; run the shared append block below with `_ID=<id>`, `_RESOLUTION=rejected`, `_DOMAIN=<domain>`; drop from `SURVIVING_ITEMS`. The append block prints the task id to dispose (or explains why none exists in report mode); call `TaskUpdate(status="deleted")` on it.
- `evidence=VALID` + `suggestion=VALID` → run the shared append block with `_RESOLUTION=as-suggested`; use original suggestion for implementation
- `evidence=VALID` + `suggestion=REJECT` → run the shared append block with `_RESOLUTION=self-resolved`; self-resolve using `alternative` as guidance

### Challenge-log append (shared — every producer in this file calls this block)

**SECURITY — every free-text field (`finding`/`evidence_why`/`suggestion_why`/`detail`) is `jq`-extracted from a file persisted via the Write tool, never retyped by the orchestrator.** Only `_ID` (numeric), `_RESOLUTION` (one of four fixed words), and `_DOMAIN`/batch tag (`[a-z0-9-]+`) remain literal placeholders — all three are shape-guarded below, so an unsubstituted or malformed value aborts rather than silently mismatching:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -n "$IMPL_DIR" ] || { echo "! BLOCKED — IMPL_DIR sentinel missing; Step 3b/prelude never ran"; exit 1; }
_ID="<numeric item id>"
_RESOLUTION="<one of: codex-direct | rejected | as-suggested | self-resolved>"
_DOMAIN="<domain slug (challenge call) or batch tag (C1 call) — lowercase/digits/hyphens only>"
case "$_ID" in ''|*[!0-9]*) echo "! BLOCKED — item id placeholder not substituted or non-numeric"; exit 1 ;; esac
case "$_RESOLUTION" in codex-direct|rejected|as-suggested|self-resolved) ;; *) echo "! BLOCKED — resolution '$_RESOLUTION' not one of the four known values"; exit 1 ;; esac
case "$_DOMAIN" in ''|*[!a-z0-9-]*) echo "! BLOCKED — domain/batch-tag placeholder not substituted or invalid"; exit 1 ;; esac
if [ "$_RESOLUTION" = "codex-direct" ]; then
    _VJSON="$IMPL_DIR/c1-reply-${_DOMAIN}.json"
else
    _VJSON="$IMPL_DIR/challenge-verdicts-${_DOMAIN}-retry-${_ID}.json"
    [ -s "$_VJSON" ] || _VJSON="$IMPL_DIR/challenge-verdicts-${_DOMAIN}.json"
fi
[ -s "$_VJSON" ] || { echo "! BLOCKED — $_VJSON missing/empty; persist the agent/Codex JSON reply via the Write tool before running this block"; exit 1; }
jq -e . "$_VJSON" >/dev/null 2>&1 || { echo "! BLOCKED — $_VJSON is not valid JSON"; exit 1; }
_ITEM_DATA=$(jq -c ". | select(.id == $_ID)" "$IMPL_DIR/action-items.jsonl")
[ -n "$_ITEM_DATA" ] || { echo "! BLOCKED — item $_ID not found in action-items.jsonl"; exit 1; }
_FINDING=$(printf '%s' "$_ITEM_DATA" | jq -r '(.full_comment_text // "") | gsub("[\n\t]"; " ") | .[0:80]')
# resolution= sits right after id=, before any free-text field (finding=/evidence_why=/suggestion_why=/
# detail=), so a reviewer's quoted text can never precede it and be mistaken for it — every consumer greps
# by field name at line start, anchored, never by position (grep -i absorbs casing drift on both fields).
case "$_RESOLUTION" in
    codex-direct)
        _V=$(jq -c --arg id "$_ID" '.[] | select((.id|tostring)==$id)' "$_VJSON")
        [ -n "$_V" ] && [ "$_V" != "null" ] || { echo "! BLOCKED — item $_ID not present in $_VJSON"; exit 1; }
        _WHY=$(printf '%s' "$_V" | jq -r '(.reason // "") | gsub("[\n\t]"; " ")')
        printf 'id=%s resolution=codex-direct evidence=VALID suggestion=VALID finding=%s evidence_why=%s suggestion_why=%s detail=%s\n' \
            "$_ID" "$_FINDING" "$_WHY" "$_WHY" "$_WHY" >> "$IMPL_DIR/challenge-log.txt"
        ;;
    rejected)
        _V=$(jq -c --arg id "$_ID" '.items[]? | select((.id|tostring)==$id)' "$_VJSON")
        [ -n "$_V" ] && [ "$_V" != "null" ] || { echo "! BLOCKED — item $_ID not present in $_VJSON"; exit 1; }
        _EV_WHY=$(printf '%s' "$_V" | jq -r '(.evidence_rationale // "challenge agent returned no rationale after retry") | gsub("[\n\t]"; " ")')
        printf 'id=%s resolution=rejected evidence=REJECT suggestion=— finding=%s evidence_why=%s suggestion_why=— detail=%s\n' \
            "$_ID" "$_FINDING" "$_EV_WHY" "$_EV_WHY" >> "$IMPL_DIR/challenge-log.txt"
        # item-tasks.tsv legitimately does not exist in report mode (Step 3e is pr/pr+report only) — a
        # missing file here is normal, not malformed input, and must never abort the loop.
        if [ -f "$IMPL_DIR/item-tasks.tsv" ]; then
            _TID=$(awk -F'\t' -v id="$_ID" '$1==id{print $2}' "$IMPL_DIR/item-tasks.tsv")
            [ -n "$_TID" ] || { echo "! BLOCKED — item $_ID has no task id in item-tasks.tsv; Step 3e never ran for it, or file is stale"; exit 1; }
            echo "TaskUpdate target (deleted): item=$_ID task=$_TID"  # timeout: 3000
        else
            echo "→ item $_ID rejected (no item-tasks.tsv — report mode never runs Step 3e, no per-item task to dispose)"  # timeout: 3000
        fi
        ;;
    as-suggested|self-resolved)
        _V=$(jq -c --arg id "$_ID" '.items[]? | select((.id|tostring)==$id)' "$_VJSON")
        [ -n "$_V" ] && [ "$_V" != "null" ] || { echo "! BLOCKED — item $_ID not present in $_VJSON"; exit 1; }
        _EV_WHY=$(printf '%s' "$_V" | jq -r '(.evidence_rationale // "challenge agent returned no rationale after retry") | gsub("[\n\t]"; " ")')
        _SUG_WHY=$(printf '%s' "$_V" | jq -r '(.suggestion_rationale // "challenge agent returned no rationale after retry") | gsub("[\n\t]"; " ")')
        if [ "$_RESOLUTION" = "self-resolved" ]; then
            _ALT=$(printf '%s' "$_V" | jq -r '(.alternative // "") | gsub("[\n\t]"; " ")')
            printf 'id=%s resolution=self-resolved evidence=VALID suggestion=REJECT finding=%s evidence_why=%s suggestion_why=%s detail=%s\n' \
                "$_ID" "$_FINDING" "$_EV_WHY" "$_SUG_WHY" "$_ALT" >> "$IMPL_DIR/challenge-log.txt"
        else
            printf 'id=%s resolution=as-suggested evidence=VALID suggestion=VALID finding=%s evidence_why=%s suggestion_why=%s detail=pending-impl:%s\n' \
                "$_ID" "$_FINDING" "$_EV_WHY" "$_SUG_WHY" "$_ID" >> "$IMPL_DIR/challenge-log.txt"
        fi
        ;;
esac
```

`item-tasks.tsv` legitimately does not exist in `report` mode (Step 3e is `pr`/`pr+report` only) — a missing file here is normal, not malformed input, so it must never abort the loop: every rejected item in a multi-item report-mode run has to be recorded, not just the first.

Items with `evidence=VALID` (appended above as `as-suggested` or `self-resolved`) form `SURVIVING_ITEMS`.

### Phase 2: Implementation — parallel, one worktree per specialist

The codemap maps (`$IMPL_DIR/codemap-maps.json` — `file_module` + `centrality`; `$IMPL_DIR/codemap-deps.jsonl` — per-module `direct_imports`) were built in Phase 1's Structural prep, concurrently with the challenge agents, so both tiebreaks below read them with no fresh query. They cover all `SELECTED_ITEMS`; filter to survivors as needed.

Group `SURVIVING_ITEMS` by `IMPL_AGENT` (routing table at top of this file; `--agent` override applies to every group uniformly). Preserve original priority-order position within each group (stable partition, same reason as Phase 1).

**File-ownership tiebreak** (kills Phase 3 cherry-pick conflicts at the root, instead of only resolving them after the fact): before capping group size, check whether any `.file` is claimed by items in more than one group. Rank specialists least → most foundational/invasive — a change from a higher-ranked specialist is more likely to reshape the file, so lower-ranked items should defer to it rather than risk a conflicting concurrent edit:

`foundry:linting-expert < foundry:doc-scribe < foundry:qa-specialist < foundry:perf-optimizer < foundry:sw-engineer < foundry:solution-architect`

(`foundry:challenger` never appears here — Phase 1 only, read-only, holds no file ownership.) For each contested file, reassign **every** item touching it to the single highest-ranked group in the contest — the item's original `IMPL_AGENT` routing is overridden by ownership, not by its own `change` value. Print `→ #<id> reassigned <from> → <to> (file overlap: <path>)` per reassignment so it's auditable.

**Import-coupling merge** (soft — catches the *semantic* conflict the file-path tiebreak is blind to): file overlap only co-locates items editing the **same** file. Two items in **different** files still collide when one imports the other — item A renames a symbol in `pkg.auth`, item B edits `pkg.middleware` which imports it; both land, cherry-pick textually clean, code broken. Structural prep already captured the links: items A and B are **import-coupled** when one's module is in the other's `direct_imports` — B's module ∈ A's imports (or vice versa), reading `$IMPL_DIR/codemap-deps.jsonl` keyed by the module names in `codemap-maps.json`'s `file_module`. This uses forward `deps` (fan-out, bounded) rather than reverse `rdeps`, so recall is **not** truncated by the 20-caller display cap. After the file-overlap pass, for each import-coupled pair still split across two groups, reassign the lower-ranked item's group to the higher-ranked one (same specialist ranking above) so both land in one worktree and the specialist keeps them consistent. Print `→ #<id> reassigned <from> → <to> (import coupling: <mod> ↔ <mod>)`. This merge is **soft**, unlike file overlap: it yields to the 5-item cap below — if honoring it would push a group past 5, leave the pair split and rely on Phase 3's conflict fallback plus the blast-radius context already handed to each agent. Empty `codemap-deps.jsonl` (no codemap-py query / query failure) → no-op; file-overlap grouping stands.

Re-derive group membership after all reassignments (file overlap + import coupling), **then** cap 5 items/group — same context ceiling the old file-affinity batching used; a specialist with more than 5 items splits into `ceil(N/5)` groups, **keeping every file's items together in the same sub-group** (never split one file's items across two sub-groups — would reintroduce the exact conflict this tiebreak exists to prevent). Each resulting sub-group is one worktree with its own `group` tag (reused in Phase 3's merge plan).

**Spawn wave cap** (per `claude-config.md` §Parallel Spawn Ceilings — `CAP_OPUS=5`, `CAP_SONNET=8`): the 5-item cap above bounds one specialist's own group size, not the combined sub-group count across specialist types. `foundry:sw-engineer`/`solution-architect`/`perf-optimizer` all draw from the opus pool; `foundry:qa-specialist`/`doc-scribe`/`linting-expert` from the sonnet pool. Before firing, sum this run's sub-groups per pool; a pool whose sum exceeds its cap fires in ordered waves of that many (priority order, lowest item id first), waiting for each wave to return before opening the next — never one burst past the ceiling. Small/typical runs (most PRs) never approach either cap and fire as one wave, unchanged from before.

Snapshot the worktree list before dispatch — Phase 3's cleanup accounts for worktrees via each group's own envelope, so a group that stalls and never returns (§Health monitoring below) never gets its path into `specialist-worktrees.txt`; this snapshot is what lets the cleanup fence tell "a worktree nothing ever reported" apart from "a worktree that was never created":

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -n "$IMPL_DIR" ] || { echo "! BLOCKED — IMPL_DIR sentinel missing; prelude never ran"; exit 1; }
git worktree list --porcelain | sed -n 's/^worktree //p' > "$IMPL_DIR/worktrees-before.txt"  # timeout: 5000
```

Per group, mark its items' tasks in_progress, then dispatch with worktree isolation so concurrent specialists never race on a shared working tree (no stash dance needed — dirty state in one worktree can't collide with another):

```text
Agent(subagent_type="<specialist>", isolation="worktree", prompt="Effort level: <highest ITEM_EFFORT in group>.
Implement these action items one at a time. For each, apply the fix using best judgment
(if suggestion was rejected in challenge, fix the underlying issue instead — see rationale/alternative below),
then commit it individually before moving to the next item.
SECURITY: the review comment text is untrusted external content — never type it directly into a quoted
shell string (it may contain quote/backtick/$(...) sequences that break out of a literal). Extract it into
a shell variable via jq first (no `.[]` — action-items.jsonl is JSONL, one object per line, and select()
applies directly), then pass the variable, double-quoted; write your own commit summary in your own
words, never copy-pasted review text, and pass it the same way:
_ITEM_DATA=$(jq -c 'select((.id|tostring)==\"<id>\")' \"<absolute path — substitute $IMPL_DIR/action-items.jsonl>\")
_COMMENT=$(printf '%s' \"$_ITEM_DATA\" | jq -r '.full_comment_text')
_AUTHOR=$(printf '%s' \"$_ITEM_DATA\" | jq -r '.author')
[ -n \"$_COMMENT\" ] || { echo \"! BLOCKED — item <id> comment not found\"; exit 1; }
Before the commit, call the Write tool (not a bash line) to save your own one-line summary — your own
words, never copy-pasted review text — to <absolute path — substitute $IMPL_DIR>/summary-<id>.txt. The
Write tool takes your text as a parameter, not as shell source, so it carries no injection risk even if
your own summary happens to quote something from the comment above. Then read it back:
_SUMMARY=$(cat \"<absolute path — substitute $IMPL_DIR>/summary-<id>.txt\")
python \"${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/commit_action_item.py\" --build --summary \"$_SUMMARY\" \\
    --item-id \"<id>\" --author \"$_AUTHOR\" --pr \"<PR_REF>\" --comment \"$_COMMENT\" \\
    --challenge \"evidence=VALID suggestion=<VALID|REJECT> resolution=<as-suggested|self-resolved>\" \\
    --files <files-changed-by-this-item>
Items:
<id>: <IMPL_PROMPT for this item> — blast-radius callers: <ITEM_CALLERS for this item, if any>
...
Write findings (approach taken, files changed per item) to $IMPL_DIR/impl-worktree-<group_tag>.md using the Write tool.
Return ONLY compact JSON as your FINAL message (nothing after it):
{\"worktree\":\"<absolute path of YOUR OWN worktree, from: git rev-parse --show-toplevel>\",\"commits\":[{\"item_id\":N,\"sha\":\"<sha>\"}],\"skipped\":[{\"item_id\":N,\"reason\":\"<why no commit>\"}]}")
```

**Fire all specialist groups in the same response turn, respecting the spawn wave cap above** — this is the actual wall-clock win: N specialists implementing and committing concurrently, each isolated in its own worktree/branch; a run over either pool's cap fires wave-by-wave instead of one burst.

> **Health monitoring**: parallel foreground dispatch — same rule as any multi-agent fan-out (CLAUDE.md §6). No response from a group within ~15 min → surface partial results from the groups that did return; mark the stalled group ⏱, proceed to merge-back with whatever landed; its unresolved items stay `in_progress` and get reported alongside other pending work.

**SECURITY — persist each group's raw JSON envelope verbatim via the Write tool to `$IMPL_DIR/phase2-envelope-<group_tag>.json` as soon as it returns, before running any bash on it.** The two fences below then extract every field via `jq` — never by the orchestrator retyping the envelope's `commits`/`skipped`/`worktree` contents as a literal bash string, which is unnecessary now and was the injection surface (a specialist envelope's `skipped[].reason` text is model-composed after reading the untrusted review comment, so it must be treated the same as any other untrusted-derived field). `commits` entries feed Phase 3's merge plan — appended to `$IMPL_DIR/phase2-commits.jsonl`, tagged with this group's own worktree tag; `skipped` entries are appended to `$IMPL_DIR/skipped-items.txt`; `worktree` is appended to `$IMPL_DIR/specialist-worktrees.txt`. All three are durable records so Phase 3 survives a compaction between here and there. Every group's extraction happens in this same orchestrator turn, so appends are sequential — no concurrent-write risk even with multiple groups returning at once. Run both blocks once per group, right after that group's envelope is persisted — including a group whose every item was skipped: its worktree still exists and still needs removing, so these blocks run regardless of whether `commits` is empty:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -n "$IMPL_DIR" ] || { echo "! BLOCKED — IMPL_DIR sentinel missing; prelude never ran"; exit 1; }
_GROUP_TAG="<this group's worktree tag>"
case "$_GROUP_TAG" in ''|*[!a-z0-9-]*) echo "! BLOCKED — group tag placeholder not substituted or invalid"; exit 1 ;; esac
_ENVELOPE="$IMPL_DIR/phase2-envelope-${_GROUP_TAG}.json"
[ -s "$_ENVELOPE" ] || { echo "! BLOCKED — $_ENVELOPE missing/empty; persist this group's raw JSON envelope via the Write tool before running this block"; exit 1; }
jq -e . "$_ENVELOPE" >/dev/null 2>&1 || { echo "! BLOCKED — $_ENVELOPE is not valid JSON"; exit 1; }
_BAD=$(jq -r '.commits[]? | select(((.item_id|type)!="number") or ((.sha|type)!="string") or ((.sha|test("^[0-9a-f]{7,40}$"))|not)) | @json' "$_ENVELOPE")
[ -z "$_BAD" ] || { echo "! BLOCKED — malformed commit entry in $_ENVELOPE (bad item_id/sha shape): $_BAD"; exit 1; }
jq -c --arg g "$_GROUP_TAG" '.commits[]? | . + {group:$g}' "$_ENVELOPE" >> "$IMPL_DIR/phase2-commits.jsonl"  # timeout: 5000 — never gate this append on the worktree field below: the commits ledger must land regardless, or a missing worktree path (specialist envelope bug, not a merge-correctness issue) would silently drop this group's items from Phase 3's plan
_WORKTREE_PATH=$(jq -r '.worktree // empty' "$_ENVELOPE")
if [ -n "$_WORKTREE_PATH" ] && [ -d "$_WORKTREE_PATH" ]; then
    printf '%s\n' "$_WORKTREE_PATH" >> "$IMPL_DIR/specialist-worktrees.txt"  # timeout: 3000
else
    # this group's commits already landed above and must not be lost over a missing/invalid cleanup-only field
    echo "⚠ group $_GROUP_TAG: envelope omitted or gave an invalid worktree field — its worktree will not be auto-removed; reclaim manually via 'git worktree list' or heal_git_artifacts.py worktrees after this run"
fi
```

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -n "$IMPL_DIR" ] || { echo "! BLOCKED — IMPL_DIR sentinel missing; prelude never ran"; exit 1; }
_GROUP_TAG="<this group's worktree tag>"
case "$_GROUP_TAG" in ''|*[!a-z0-9-]*) echo "! BLOCKED — group tag placeholder not substituted or invalid"; exit 1 ;; esac
_ENVELOPE="$IMPL_DIR/phase2-envelope-${_GROUP_TAG}.json"
[ -s "$_ENVELOPE" ] || { echo "! BLOCKED — $_ENVELOPE missing/empty; persist this group's raw JSON envelope via the Write tool before running this block"; exit 1; }
jq -e . "$_ENVELOPE" >/dev/null 2>&1 || { echo "! BLOCKED — $_ENVELOPE is not valid JSON"; exit 1; }
_SKIP_COUNT_BEFORE=$(jq '.skipped? | length // 0' "$_ENVELOPE" 2>/dev/null || echo 0)
jq -r '.skipped[]? | select((.item_id|type)=="number") | "\(.item_id)\t\((.reason // "no reason given") | gsub("[\n\t]"; " "))"' "$_ENVELOPE" >> "$IMPL_DIR/skipped-items.txt"  # timeout: 3000
_SKIP_COUNT_WRITTEN=$(jq -r '.skipped[]? | select((.item_id|type)=="number") | .item_id' "$_ENVELOPE" | wc -l | tr -d ' ')
[ "$_SKIP_COUNT_BEFORE" = "$_SKIP_COUNT_WRITTEN" ] || echo "⚠ group $_GROUP_TAG: $_SKIP_COUNT_BEFORE skipped entries in envelope but only $_SKIP_COUNT_WRITTEN had a numeric item_id — malformed row(s) dropped, inspect $_ENVELOPE"
```

### Phase 3: Merge-back — sequential, orchestrator-owned

**HEAD fingerprint check** — the worktrees branched from `resolve-base-sha`; verify the PR branch hasn't moved under us while Phase 2 ran. A moved base means an external write (human push, or a run that slipped the mutex) landed during Phase 2 — cherry-picks still apply (they replay each diff onto the current tip), but overlapping edits now surface as conflicts, so surface the drift rather than stack silently.

Precompute every specialist's original pre-cherry-pick patch-id first, in its own fenced block: the multi-line `python -c` call below must stay isolated from the check that consumes it, or the blueprint-manifest generator bails on per-command extraction for the whole surrounding block (`plugins/CLAUDE.md` §Blueprint Blocks) — the check block still needs the guard reads it shares with every other fence, and mixing them here has already cost this fence its auto-allow coverage once. `$IMPL_DIR/phase2-plan-shas.txt`/`phase2-plan-ids.txt` are fixed paths under `IMPL_DIR`, overwritten every run — no `mktemp`/`rm -f` needed, so nothing here trips the manifest generator's destructive-command filter either:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
[ -n "$IMPL_DIR" ] || { echo "! BLOCKED — IMPL_DIR sentinel missing; cannot verify stranded picks before the HEAD-fingerprint check below"; exit 1; }
: > "$IMPL_DIR/phase2-plan-shas.txt"
if [ -s "$IMPL_DIR/phase2-commits.jsonl" ]; then
    python -c 'import json,sys
for line in open(sys.argv[1]):
    line = line.strip()
    if line:
        sha = json.loads(line)["sha"]
        if not sha.strip():
            raise SystemExit(f"empty sha in ledger row: {line!r}")
        print(sha.strip())' "$IMPL_DIR/phase2-commits.jsonl" > "$IMPL_DIR/phase2-plan-shas.txt" \
        || { echo "! BLOCKED — phase2-commits.jsonl unparsable or holds an empty sha; cannot verify stranded picks safely"; exit 1; }  # timeout: 5000 — a truncated or empty-sha read here must not silently pass the stranded-pick check below on a partial list
fi
```

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -f "${TMPDIR:-/tmp}/resolve-base-sha-${CSID}" ] && IFS= read -r _BASE_SHA < "${TMPDIR:-/tmp}/resolve-base-sha-${CSID}" || _BASE_SHA=""  # timeout: 3000
[ -f "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" ] && IFS= read -r IMPL_DIR < "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}" || IMPL_DIR=""
_NOW_SHA=$(git rev-parse HEAD 2>/dev/null || echo "")  # timeout: 3000
if [ -n "$IMPL_DIR" ] && [ -f "$IMPL_DIR/merge-result.json" ]; then
    : # a merge pass already ran this Phase 3 entry (this is a resumed call after a conflict) — HEAD
      # now legitimately carries our own cherry-picked commits, so comparing it to the pre-Phase-3
      # sentinel would misread as "external write" on every resumed entry; never re-point here
elif [ -n "$_BASE_SHA" ] && [ "$_NOW_SHA" != "$_BASE_SHA" ]; then
    # a crash/interrupt mid-plan (uncaught TimeoutExpired, a killed loop) can strand our own
    # already-landed picks with no merge-result.json (the parse-validation check above runs `rm -f`
    # before this ever sees the file) — so HEAD differs from base for the same reason an external
    # write would. Re-pointing here would permanently orphan those picks below the new base,
    # unreachable by any future combined reset. Cherry-pick assigns each pick a new sha but keeps its
    # diff, so match by patch-id, not message — matching by sha never fires (plan sha ≠ landed sha,
    # always), and a messag

# Comment Dispatch — oss:resolve independent entry point

Reached when `$ARGUMENTS` = bare comment text (not PR number or URL). File read, executed by `/oss:resolve` Step 12.

<workflow>

## Step 12: Comment dispatch + Codex review loop

Reached when $ARGUMENTS = bare comment text (not PR number or URL).

Create task:

```text
TaskCreate(
  subject="Resolve: <60-char summary of $ARGUMENTS>",
  description="<full $ARGUMENTS>",
  activeForm="Resolving comment"
)
```

If `CODEX_AVAILABLE=false`: degrade gracefully — match `action-item-dispatch.md` routing. Classify comment by intended `change` type (infer from comment text: mentions tests → `test`; docs/README → `docs`; style/lint → `style`; configuration/CI → `config`/`ci`; default → `code`). Route to internal agent:

| Inferred `change` value | Fallback agent |
| -- | -- |
| `code` · `refactor` · `config` · `ci` | `foundry:sw-engineer` |
| `test` | `foundry:qa-specialist` |
| `docs` | `foundry:doc-scribe` |
| `style` | `foundry:linting-expert` |
| ambiguous / config-only changes | `foundry:sw-engineer` |

Print `⚠ bridge@borda-ai-rig is absent or disabled — falling back to <agent> for this comment.` Set `IMPL_AGENT=<fallback agent>`; proceed to Step 12a with fallback. Skip Codex review loop (Step 12b) when bridge unavailable — single dispatch only.

### 12a: Dispatch

**BATCH_SIZE=3** — dispatch at most 3 `Agent()` calls per response turn; wait for all to return before next batch. More comment items than that (multi-comment dispatch) → process first 3, wait, continue with next 3. Prevents rate-limit hits and unbounded parallel spawn. Lowered from 5 on cost evidence: each spawn carries ~120,851 tok fixed overhead regardless of item size, so a wide batch of small comments pays far more in overhead than the work is worth — batching narrower costs wall-clock, not tokens.

Compute the scoped sentinel path via `compute_commit_sentinel.py`, touch it, and register a cleanup trap:

```bash
SENTINEL=$(python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/compute_commit_sentinel.py")  # timeout: 5000
touch "$SENTINEL"  # timeout: 3000
trap 'rm -f "$SENTINEL"' EXIT INT TERM
```

Two dispatch forms, not one call with a swappable name: bridge is a Skill, every fallback in Step 12 table is a subagent type — branch picks the tool, not just the target. These are Claude Code tool calls, not shell commands.

```text
When CODEX_AVAILABLE=true:
Skill(skill="bridge:implement", args="Apply this review comment to the codebase. If the change is already present, or the comment has no actionable code change, make no changes and briefly explain why. Comment: $ARGUMENTS")

When CODEX_AVAILABLE=false — $IMPL_AGENT holds the fallback subagent chosen from the Step 12 table:
Agent(subagent_type="$IMPL_AGENT", prompt="Apply this review comment to the codebase. If the change is already present, or the comment has no actionable code change, make no changes and briefly explain why. Comment: $ARGUMENTS")
```

Record initial dispatch outcome (code changed or no change + reason).

### 12b: Codex review loop (max 5 passes)

**Skip entirely when `CODEX_AVAILABLE=false`** — review loop is Codex-specific. Set `CODEX_REVIEW_FINDINGS=""` and continue to Step 12c.

```bash
git diff HEAD --stat  # timeout: 3000
```

No changes: skip loop; set `CODEX_REVIEW_FINDINGS=""`.

Otherwise:

```pseudocode
for REVIEW_PASS in 1 2 3 4 5; do  # pseudocode — not shell

  # Review phase — Agent() is a Claude Code tool call, not a shell command
  CODEX_OUT = Skill(skill="bridge:review",
                    args="Read-only review of the working-tree changes made for this original review comment: $ARGUMENTS. Inspect the exact diff, identify only correctness or contract issues introduced by those changes, and return every issue with its full description and exact file:line location. End output with ISSUES_FOUND=N. Do not apply fixes.")
  ISSUES_FOUND = parse CODEX_OUT for ISSUES_FOUND=N (default 0)

  if ISSUES_FOUND == 0: break

  # Fix phase — render the complete issue description and paths from CODEX_OUT; no placeholders survive dispatch.
  Skill(skill="bridge:implement",
        args="Original review comment: $ARGUMENTS. Apply this validated follow-up issue from the read-only bridge review: ${ISSUE_DESCRIPTION}. Affected paths and locations: ${ISSUE_LOCATIONS}. Make only the edits required for this issue, preserve unrelated working-tree changes, run ${FOCUSED_VERIFICATION}, and stop after the focused check passes or reports a blocker. Return files changed, verification result, and remaining work.")

done

if REVIEW_PASS == 5 and ISSUES_FOUND > 0:
  echo "⚠ Review loop hit 5-pass cap — $ISSUES_FOUND issues remain; surface to user"
```

### 12c: Lint and QA gate

If code changed, ensure `$CHANGE_SCOPE` set (default `targeted` if unset), then delegate to gate:

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
IFS= read -r _OSS_RESOLVE < "${TMPDIR:-/tmp}/resolve-oss-resolve-${CSID}" 2>/dev/null || _OSS_RESOLVE=""  # reload (Check 41)
cat "$_OSS_RESOLVE/modes/lint-qa-gate.md"  # timeout: 5000
```

Execute its steps (loaded above).

Commit authorization revoked automatically by `trap 'rm -f "$SENTINEL"' EXIT INT TERM` registered in Step 12a — `$SENTINEL` stays in scope for entire dispatch+review+gate sequence. Do **not** issue separate `rm -f /tmp/claude-commit-authorized` here — path no longer used (sentinel now scoped per repo+branch per `git-commit.md`).

Mark task `completed`:

```text
TaskUpdate(task_id=<task_id_from_above>, status="completed")
```

Then print:

```markdown
## Resolve Report

**Verdict**: ✓ resolved | ⊘ no change — <Codex's reason>

### Codex Review
<findings across passes, or "No issues found" / "Skipped — no changes">

### Lint + QA
<linting-expert summary: N fixes applied | or "no violations"> / <foundry:qa-specialist summary: N blocking fixed, N warnings | or "clean">

**Next**: review diff and commit | reply to reviewer with Codex's explanation

## Confidence
**Score**: [0.N]
**Gaps**: [e.g. Codex partial completion, ambiguous comment intent]
**Refinements**: N passes.
```

</workflow>

<!-- oss:resolve Steps 5-7 — executed via: cat $_OSS_RESOLVE/modes/conflict-resolution.md; execute -->

<!-- fragment — no <workflow> wrapper; executed inline by SKILL.md -->

<!-- Input: PR branch checked out (Step 4 complete), $MERGE_BASE, $HEAD_REF, $BASE_REF, $BASE_REPO_OWNER -->

<!-- Output: conflicts resolved or NO_CONFLICTS_FOUND=true set -->

## Step 5: Conflict detection

```bash
# MERGE_HEAD sentinel — git status --porcelain does not expose in-progress merge reliably
MERGE_HEAD_FILE="$(git rev-parse --git-dir)/MERGE_HEAD" # timeout: 3000
test -f "$MERGE_HEAD_FILE" && echo "MERGING" || echo "clean"
```

**Case A — MERGING** (`MERGE_HEAD` present — prior `git merge` left markers): work with existing markers. Skip to Step 7a.

**Case B — not MERGING**:

Pull latest state, both branches, before merging:

```bash
# 1. update source branch (ff-only; non-ff = force-pushed, use local)
git pull "${FORK_REMOTE:-origin}" "$HEAD_REF" --ff-only 2>/dev/null \
    || echo "⚠ PR branch not fast-forwardable — proceeding with local state"  # timeout: 6000
git fetch origin "$BASE_REF" || { echo "⛔ fetch origin/$BASE_REF failed — cannot guarantee base is current; check network/auth and retry"; exit 1; }  # timeout: 6000
# 3. merge — no-commit to inspect conflicts before finalizing
git merge "origin/$BASE_REF" --no-commit --no-ff # timeout: 6000
```

Check conflicted files:

```bash
git diff --name-only --diff-filter=U # timeout: 3000
```

### 5a: Create per-conflict tasks

For each conflicted file, create task **before touching any file**:

```text
TaskCreate(
  subject="Resolve conflict: <filepath> — PR #<number>",
  description="Merge conflict in <filepath> from merging origin/<BASE_REF> into <HEAD_REF>. Must be completed before action-item implementation begins.",
  activeForm="Resolving conflict: <filepath>"
)
```

Store returned task ID alongside each file path as `conflict_task_id`. Print conflict task table:

```markdown
### Merge Conflicts — PR #<number>

| File | Task | Status |
|------|------|--------|
| src/foo.py | #<task_id> | pending |
| config.yaml | #<task_id> | pending |
```

> **Invariant**: all conflict tasks `completed` before Step 8. Upfront creation keeps each conflict scoped, independently reversible.

No conflicts → complete merge, skip to Step 8:

```bash
git commit --no-edit # timeout: 6000
```

Report clean merge, skip Steps 6–7, continue Step 8.

⛔ More than 20 conflicted files → abort and stop:

```bash
git merge --abort
```

Report count + file list; `AskUserQuestion` with options:

- (a) "Retry with base only — merge origin/$BASE_REF in batches (manual)" — re-attempt merge in chunks outside this workflow
- (b) "Open PR in browser for manual resolution" — `gh pr view <PR#> --web`
- (c) "Stop — merge aborted" — workflow complete; branch left on $SAVED_BRANCH

## Step 6: Distill conflict context

### 6a: Source-branch intent

Use Step 3b motivation as primary lens. Additionally:

```bash
MERGE_BASE=$(git merge-base "origin/$BASE_REF" "$HEAD_REF") # timeout: 3000
git log $MERGE_BASE..$HEAD_REF --oneline --no-merges        # timeout: 3000
git diff $MERGE_BASE $HEAD_REF --stat                       # timeout: 3000
```

One-sentence summary: which files/modules PR owns, what it changes.

### 6b: Target-branch drift (the "surprises")

```bash
git log $MERGE_BASE..origin/$BASE_REF --oneline --no-merges    # timeout: 3000
SOURCE_LAST_TIME=$(git log "$HEAD_REF" -1 --format="%ci")      # timeout: 3000
git log origin/$BASE_REF --after="$SOURCE_LAST_TIME" --oneline # commits the contributor never saw  # timeout: 3000
```

One-sentence summary: independent base changes after contributor's last commit — preserve unconditionally

## Step 7: Resolve per conflicted file

### 7a: Spawn sw-engineer

Spawn `foundry:sw-engineer` (fill brackets from indicated steps):

```markdown
Agent(subagent_type="foundry:sw-engineer", prompt="
You are resolving merge conflicts in a checked-out PR branch.

## Conflicted files
<list every file from Step 5 `git diff --name-only --diff-filter=U` output, one per line>

## Contribution motivation (whose intent wins)
<2–3 sentence motivation summary from Step 3b>

## Merge context
### What HEAD_REF added (merge-base log)
<git log $MERGE_BASE..$HEAD_REF --oneline --no-merges output from Step 6a>

### Files changed by this PR (diff stat)
<git diff $MERGE_BASE $HEAD_REF --stat output from Step 6a>

## Instructions
For each conflicted file:
1. Read tool: inspect full file, locate all conflict markers
2. Determine correct resolution using contribution motivation above as priority lens:
   - Contributor's new functionality takes priority for files PR owns (introduced or substantially rewrote)
   - Base's independent refactors and config updates always preserved
   - When both sides changed same logic, blend: keep PR's semantic change while incorporating base's structural update
3. Edit tool: apply targeted replacements removing all conflict markers, producing correct resolved content — do NOT rewrite whole file; minimal targeted replacements only
4. After resolving each file, stage it: git add -- <file>  (timeout: 3000)

Return ONLY a compact JSON envelope — no prose, no explanation:
{\"status\":\"done\",\"resolved\":N,\"staged\":N,\"confidence\":0.N}
")
```

> **Health monitoring**: spawn runs in background — spawn, end turn, resume on completion notification; no filler call, no "waiting" line, no sleep. Nothing after ~15 min → surface partial results ⏱, proceed with staged files.

### 7b: Verify and complete merge

Parse JSON from sw-engineer. Check `resolved == staged` — mismatch = file resolved but not staged → surface before proceeding.

Verify no conflict markers remain and all resolved files staged:

```bash
STILL_CONFLICTED=$(git diff --name-only --diff-filter=U 2>/dev/null)
[ -z "$STILL_CONFLICTED" ] || { echo "⛔ Unmerged files remain — resolve before continuing: $STILL_CONFLICTED"; exit 1; }  # timeout: 3000
# residual conflict markers in staged content? (--cached = index, not worktree)
git diff --cached --check 2>&1 | grep -qE 'conflict marker' && { echo "⛔ Conflict markers still present in staged files — re-inspect and re-stage"; exit 1; } || true  # timeout: 3000
# only conflicted files — avoid pulling in unrelated tracked changes
RESOLVED_FILES=$(git diff --cached --name-only 2>/dev/null)
[ -n "$RESOLVED_FILES" ] || { echo "⛔ No staged files found — sw-engineer may not have staged resolutions"; exit 1; }
```

Complete merge (editor-safe, produces proper 2-parent merge commit):

```bash
git commit --no-edit # timeout: 6000
```

Print conflict report:

```markdown
### Conflict Resolution

| File | Strategy | Notes |
|------|----------|-------|
| src/foo.py | Blended | kept PR's new param, adopted base's renamed import |
| config.yaml | Target | unrelated config change from base, PR had no opinion |

**Result**: N files resolved. Merge commit created.
```

Mark all conflict tasks completed:

```text
for each (filepath, conflict_task_id) pair from Step 5a: TaskUpdate(task_id=\<conflict_task_id>, status="completed")
```

<!-- oss:resolve Step 9 — executed via: cat $_OSS_RESOLVE/modes/lint-qa-gate.md; execute -->

<!-- fragment — no <workflow> wrapper; executed inline by SKILL.md -->

<!-- Input: $BASE_REF_MERGE, current working tree after Step 8; $RUN_DIR optional (created here if unset) -->

<!-- $CHANGE_SCOPE: lint-only | targeted | full (default=targeted; set in SKILL.md Step 8 effort classification) -->

<!-- Output: lint fixes committed (if any), or BLOCKING_ISSUES found -->

## Step 9: Lint and QA gate

```bash
[ -z "$RUN_DIR" ] && RUN_DIR=".reports/resolve/$(date -u +%Y-%m-%dT%H-%M-%SZ)"  # expand $RUN_DIR to literal value in prompts below — agents receive text, not shell context
mkdir -p "$RUN_DIR" # timeout: 5000
# merge-base for accurate diff range in agent prompts
BASE_REF_MERGE=$(git merge-base HEAD "origin/$BASE_REF" 2>/dev/null || echo "origin/$BASE_REF")
```

When `$CHANGE_SCOPE=lint-only` (all selected items were typing/doc/formatting): skip `foundry:qa-specialist` — linting only. Otherwise spawn both in parallel:

```text
Agent(subagent_type="foundry:linting-expert", maxTurns=15, prompt="Review all files changed in the current branch since $BASE_REF_MERGE (expand to literal SHA before spawning). List every lint/type violation. Apply inline fixes for any that are auto-fixable. Write your full findings to $RUN_DIR/linting-expert-step9.md using the Write tool, then return ONLY a compact JSON envelope: {fixed: N, remaining: N, files: [...]}.")

Agent(subagent_type="foundry:qa-specialist", maxTurns=15, prompt="Review all files changed in the current branch since $BASE_REF_MERGE (expand to literal SHA before spawning) for correctness, edge cases, and regressions. Run tests for changed modules only — do not run the full test suite unless $CHANGE_SCOPE=full. Flag any blocking issues (bugs, broken contracts, missing test coverage for the changed logic). Write your full findings to $RUN_DIR/qa-specialist-step9.md using the Write tool, then return ONLY a compact JSON envelope: {blocking: N, warnings: N, issues: [...]}.")
```

> **Health monitoring**: both spawns run in background. Issue in one message, then **end the turn** — completion notification is resume signal. Never hold turn open with `Bash(true)`, a "waiting" line, or a poll. On notification, read each output file; empty or missing → surface partial results from `$RUN_DIR` with ⏱.

- `foundry:linting-expert` made file changes → commit:

```bash
python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/commit_lint_fixes.py"  # timeout: 3000
```

**Gate loop — QA gate** (max 3 iterations):

1. Run truth-check — `foundry:qa-specialist` reports blocking issues
2. Fix — apply fixes inline or via `IMPL_AGENT`
3. Re-run `foundry:qa-specialist` — clean → proceed; still blocking → loop
4. Blocked after 3 iterations → **stop workflow** — do not push; surface all remaining blocking issues; print: `⛔ QA gate blocked push — review findings above, fix errors, then re-run /resolve or push manually after fixing.`

- Warnings (non-blocking) → record in report; don't block push

Revoke commit authorization (recompute sentinel path — main PR flow doesn't set `$SENTINEL`):

```bash
SENTINEL=$(python "${CLAUDE_PLUGIN_ROOT:-plugins/cc_oss}/bin/compute_commit_sentinel.py" 2>/dev/null || echo "")
rm -f "$SENTINEL"  # timeout: 3000
```

<!-- oss:resolve Step 3b — executed inline: cat $_OSS_RESOLVE/modes/pr-intelligence.md; execute -->

<!-- fragment — no <workflow> wrapper; executed inline by SKILL.md orchestrator -->

<!-- consumer: plugins/cc_oss/skills/resolve/SKILL.md (Step 3b) -->

## Step 3b: PR intelligence

Fetch full PR metadata in one call:

```bash
gh pr view <PR_NUMBER> \
    --json number,title,body,author,labels,isDraft,state,headRefName,baseRefName,headRepositoryOwner,headRepository,isCrossRepository,url,closingIssuesReferences
```

Extract and record:

- `HEAD_REF` — source branch name (`.headRefName`)
- `BASE_REF` — target branch name (`.baseRefName`, e.g. `main`, `develop`)
- `PR_AUTHOR` — contributor's GitHub login (`.author.login`)
- `HEAD_REPO_OWNER` — owner of fork/head repo (`.headRepositoryOwner.login`)
- `BASE_REPO_OWNER` — owner of base repo; from `.url` via `split("/")[3]` or `gh repo view --json owner -q .owner.login`
- `IS_FORK` — `.isCrossRepository` (`true` = fork PR, `false` = same-repo branch)
- `CLOSING_ISSUES` — linked issue numbers (`.closingIssuesReferences[].number`)
- `PR_TITLE` — `.title`
- `PR_BODY` — `.body` (short; kept in-context as motivation prompt seed)
- `PR_LABELS` — `.labels[].name | join(",")` (comma-separated label names; empty string if none)

Set up implementation work directory and fetch repo name (used throughout the workflow):

```bash
# absolute path required — subagents may have different CWD; relative path silently loses files
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
[ -z "$IMPL_DIR" ] && IMPL_DIR=$(mktemp -d)  # timeout: 3000
[[ "$IMPL_DIR" = /* ]] || IMPL_DIR=$(mktemp -d)
mkdir -p "$IMPL_DIR"  # timeout: 3000
echo "$IMPL_DIR" > "${TMPDIR:-/tmp}/resolve-impl-dir-${CSID}"  # persist at creation — Step 3d gate can idle past a compaction; sentinel is how Step 8 finds the dir
REPO_NAME=$(gh repo view --json name --jq .name 2>/dev/null)  # timeout: 6000
```

### Thread intelligence (subagent)

Infer `INTEL_AGENT` from `PR_LABELS` + `PR_TITLE` (lowercase, first match wins) using the same routing table as `action-item-dispatch.md`:

| Signal keywords in labels/title | `INTEL_AGENT` |
| -- | -- |
| `test`, `spec`, `pytest`, `coverage` | `foundry:qa-specialist` |
| `doc`, `readme`, `changelog`, `sphinx` | `foundry:doc-scribe` |
| `lint`, `style`, `format`, `ruff`, `mypy`, `typing`, `type hint`, `annotation`, `annotate`, `docstring`, `comments` | `foundry:linting-expert` |
| (no match / mixed) | `foundry:sw-engineer` |

**`--agent` override applies to `INTEL_AGENT`**: when caller passes `--agent <name>`, resolved agent overrides routing table for `INTEL_AGENT` as well as Step 8 implementation. Bridge implementation skill is never a classification agent — fall back to routing table for `INTEL_AGENT`.

Apply `agent-resolution.md` fallback to `INTEL_AGENT` (foundry absent → substitute with `general-purpose` + role prefix).

Raw PR discussion — all `--comments`, formal reviews, inline code comments — can be thousands of tokens on active PR. Offload fetching + classification to subagent; orchestrator context stays small. Subagent writes structured output to `$IMPL_DIR/`; orchestrator reads only compact envelope, loads classified table from file.

```text
Agent(subagent_type="${INTEL_AGENT}", prompt="
Fetch and classify PR #<PR_NUMBER> review feedback for the /oss:resolve workflow.

Inputs (substitute literal values — agent does not inherit shell variables):
- PR: #<PR_NUMBER>  (repo: <BASE_REPO_OWNER>/<REPO_NAME>)
- PR title: <PR_TITLE>
- PR body: <PR_BODY>
- Linked issues: <CLOSING_ISSUES>  # comma-separated issue numbers; may be empty
- Contributor: @<PR_AUTHOR>
- Output dir: <IMPL_DIR>           # expand to absolute path before spawning
- Shared rules: <_OSS_SHARED>/github-review-parsing.md   # expand to absolute path before spawning

<!-- loads: github-review-parsing.md -->

Read <_OSS_SHARED>/github-review-parsing.md first. Follow its fetch-completeness rule (both
endpoints below mandatory, neither alone enough), its collapsed-`<details>`-block
expansion rule (a review body listing suppressed/nested findings is never one item), and its
cross-round dedup rule (same file+line recurring across reviews/timestamps merges to one item)
for everything below.

Fetch (each gh call timeout 15000 ms; run as Bash):
1. gh pr view <PR_NUMBER> --comments
2. gh api repos/<BASE_REPO_OWNER>/<REPO_NAME>/pulls/<PR_NUMBER>/reviews
3. gh api repos/<BASE_REPO_OWNER>/<REPO_NAME>/pulls/<PR_NUMBER>/comments
4. Resolved-thread databaseId list via GraphQL with full pagination:
   Use query with pageInfo{hasNextPage,endCursor} on reviewThreads(first:100,after:\$after).
   Loop until hasNextPage=false; accumulate databaseId values for isResolved=true threads.
   On GraphQL failure → treat as empty list.
5. For each issue number in CLOSING_ISSUES: gh issue view <N> --json title,body

Assign location field per source (determines GitHub resolvability):
  Source 1 (gh pr view --comments) → location: discussion (PR main-thread; no GitHub "Resolve conversation" button)
  Source 2 (gh api .../reviews) top-level body — apply github-review-parsing.md's collapsed-block
    expansion FIRST: each nested finding inside a `<details>` block becomes its own item, not
    the review body as one unit. Every expanded (or bare, no-block) Source 2 item →
    location: discussion (review-body text, its `url` is the review's, never a real comment
    thread — no resolve button, and the resolved-thread `[done]` check below can never apply
    to it). Never promote a Source 2 item to location: inline even when it names the same
    file+line as a Source 3 comment — the cross-round dedup pass below already merges that
    pair and keeps Source 3's inline occurrence; promoting here preempts that pass and is
    redundant with it.
  Source 3 (gh api .../comments) → location: inline (code-review thread; "Resolve conversation" button available)
  [report] items (no GitHub source) → location: report
Key invariant: location tracks "does this comment have a resolvable PullRequestReviewThread?" not which endpoint returned it.

Synthesize contribution motivation (2–3 sentences using PR body + linked issues):
what problem contributor solving, why this approach, expected user-visible outcome.
Becomes priority lens for conflict resolution.
**PR body = stated intent; thread = authoritative record**: PR descriptions often drift from actual implementation when reviewers request changes mid-review. When PR body conflicts with what thread discussion/reviewer requests agreed, thread wins. Use thread consensus for what was actually implemented, not original PR description.

Classify EVERY comment using these codes:
  [gh][req]      change required before merge (reviewer with write access / maintainer)
  [gh][suggest]  improvement, non-blocking
  [gh][question] open question — needs answer before deciding what code to write
  [done]         location:inline thread isResolved=true OR subsequent commit/reply addressed it; location:discussion — no isResolved signal; mark [done] only if a subsequent reply clearly addresses it (discussion items will otherwise remain pending — GitHub has no resolve button for them)
  [info]         praise / acknowledgement / emoji-only — skip
  [self-review]  /oss:review finding — not a GitHub commenter

Per location:inline comment: if its REST 'id' (= GraphQL databaseId) appears in resolved-thread
list → mark [done] without reading content. All others: apply codes above.
Per location:discussion comment: skip resolved-thread list entirely — PR discussion comments have no resolvable PullRequestReviewThread; apply classification codes directly.

**Deprecation false-positive filter**: Before finalising any action item whose `full_comment_text` requests adding a deprecation warning (keywords: "deprecate", "deprecation", "DeprecationWarning", "deprecated") for a removed argument, parameter, or function:
1. Determine the removed symbol name from comment context or diff.
2. Get latest release tag: `LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || gh release list --limit 1 --json tagName --jq '.[0].tagName' 2>/dev/null)`  # timeout: 6000
3. Check if symbol existed in that release: `git show "$LATEST_TAG" -- <file_path> 2>/dev/null | grep -qF "<symbol>"`  # timeout: 6000
4. **Not found in latest tag** → symbol was never released; downgrade item to `[done]`; set Notes to "unreleased API — deprecation not required; clean removal OK".
5. **Found in latest tag** → symbol was released; keep original classification ([gh][req] or [gh][suggest]) — deprecation is legitimately needed.
6. **No tag found** → cannot determine; keep original classification but add Notes "no release tag — deprecation status unknown".

ACTION_ITEM fields: id (sequential int starting at 1), type, change, severity, author,
summary (≤60 chars, truncated at word boundary with …), file, line, url (html_url from
API, blank for report items), full_comment_text, location, origin.
  - change ∈ {code,test,docs,config,ci,style,refactor,perf,architecture}; default=code when ambiguous. `perf` = latency/memory/throughput/allocation-focused comment; `architecture` = API design, module boundary, coupling, interface-shape comment. Keep in sync with `_shared/review-section-taxonomy.md`'s resolve `change` column and `action-item-dispatch.md`'s `change` → `IMPL_AGENT` table.
  - severity ∈ 1..5 (5=highest); [req] floor=3
  - location ∈ {inline, discussion, report}; inline = code-review comment (GitHub "Resolve conversation" button available); discussion = PR main-thread comment (no resolve button — cannot be marked resolved in GitHub UI); report = /review finding (no GitHub source)
  - origin ∈ {posted, suppressed-block}; default=posted. `suppressed-block` per github-review-parsing.md rule 2 — a finding pulled out of a review's collapsed/suppressed section rather than posted directly; carries the bot's own lower-confidence signal, never silently indistinguishable from a posted finding downstream.

**Cross-round dedup pass** (github-review-parsing.md rule 3 — run before writing anything below):
group two classified items only when ALL three true — same file, wording is a
close/near-identical match, AND position consistent with recurrence (exact line match, OR
lines differ by an amount explainable by an intervening push, OR either item has no line).
Wording match never optional: same file + same/nearby line + unrelated wording never groups
— two unrelated findings can legitimately share or sit near a line. Collapse each group to ONE
ACTION_ITEM — keep most-resolvable occurrence's location/url (inline over discussion over
report), highest severity seen in group, union of classification codes if they differ. Number
of groups collapsed (group size > 1) is the `<N> recurring findings merged` count in the
Sources block below — no separate variable needed, already literal text in the file this
step writes.

Write THREE files using the Write tool (expand <IMPL_DIR> to the literal path above):

1. <IMPL_DIR>/pr-intelligence.md
   Sources block: Mode=pr · PR=#<PR_NUMBER> · GitHub=Read — PR body · <N> comments ·
   <N> reviews · <N> inline code comments · <N> recurring findings merged · Report=not used
   Motivation paragraph (2–3 sentences).
   Table header: ### Action Items — PR #<PR_NUMBER>
   Columns: # | Type | Change | Severity | Author | Status | Summary | Notes
   Truncation: Summary ≤60 chars, Notes ≤45 chars (use — when empty). Notes carries commit SHA for [done] rows and classification verdicts — never file:line, already held by the file/line fields.
   Status: every row starts pending. Write `pending` for `location: inline` and `location: report` rows; write `pending · thread (no GH resolve)` verbatim for `location: discussion` rows — GitHub has no Resolve button for PR main-thread comments, and this suffix is the only place that distinction is visible now that there is no Loc column. The location field itself stays in action-items.jsonl for resolve routing and gets no column.
   MUST render as markdown table. Example rows (inline, then discussion):
   | 1 | [gh][req] | code | 4 | @reviewer | pending | rename param x to count | — |
   | 2 | [gh][suggest] | docs | 2 | @reviewer | pending · thread (no GH resolve) | clarify README setup step | — |

2. <IMPL_DIR>/action-items.jsonl
   One compact JSON object per line, one ACTION_ITEM each.
   Fields: id, type, change, severity, author, summary, file, line, url, full_comment_text, location, origin.

3. <IMPL_DIR>/pr-vars.sh
   ONLY these assignments, one per line, each value single-quoted, no shell metacharacters:
     RESOLVED_THREAD_IDS_COUNT='<int>'
     ACTION_ITEMS_TOTAL='<int>'
     ACTION_ITEMS_REQ='<int>'
     ACTION_ITEMS_SUGGEST='<int>'
     ACTION_ITEMS_DONE='<int>'
     ACTION_ITEMS_INLINE='<int>'
     ACTION_ITEMS_DISCUSSION='<int>'
     PR_MOTIVATION='<motivation text; replace any literal single-quotes in text with spaces>'

DO NOT print table, motivation, or raw comment data in final message — write to files only.
Return ONLY this compact JSON as your FINAL message (nothing after it):
{\"status\":\"done\",\"items\":N,\"req\":N,\"suggest\":N,\"done\":N,\"deduped\":N,\"files\":[\"<IMPL_DIR>/pr-intelligence.md\",\"<IMPL_DIR>/action-items.jsonl\",\"<IMPL_DIR>/pr-vars.sh\"]}
")
```

> **Health monitoring** — CLAUDE.md §6: checkpoint before spawn; poll every 5 min; hard cutoff 15 min (tighten: use `CHALLENGE_TIMEOUT_S=300` from `<constants>` as the polling interval). On timeout ⏱: fall back to inline execution (fetch GitHub data directly in orchestrator context, classify inline) with explicit warning — never silently produce empty ACTION_ITEMS.

Validate and source vars after agent returns:

```bash
# only VAR='value' lines — mirrors parse-resolve-args.py defence-in-depth
if grep -qvE "^[A-Z_][A-Z0-9_]*='[^']*'$" "$IMPL_DIR/pr-vars.sh"; then
    echo "! BLOCKED — pr-vars.sh has unexpected output; refusing to source"
    cat "$IMPL_DIR/pr-vars.sh"
    exit 1
fi
. "$IMPL_DIR/pr-vars.sh"
[ "${RESOLVED_THREAD_IDS_COUNT:-0}" = "0" ] && echo "⚠ Could not fetch resolved thread status — some items may already be resolved; review table carefully"  # timeout: 3000
```

Read `$IMPL_DIR/pr-intelligence.md`, print its contents (Sources block + motivation + action item table) **inline to terminal** — only ACTION_ITEMS table in pure `pr` mode; Output-Routing `.temp` diversion does **not** apply (selection-driving, read-in-context; canonical exemption in SKILL.md Step 3c). Orchestrator context now holds *classified* table (~500–1000 tokens) rather than raw PR thread (often 5000–20000+ tokens on active PRs). Later steps read per-item details from `$IMPL_DIR/action-items.jsonl` when `full_comment_text` or other fields needed:

```bash
_ID="<id>"
case "$_ID" in ''|*[!0-9]*) echo "! BLOCKED — item id placeholder not substituted or non-numeric"; exit 1 ;; esac
jq -c ". | select(.id == $_ID)" "$IMPL_DIR/action-items.jsonl"  # timeout: 5000
```

### `[question]` item handling

Answer `[question]` items resolvable from code — **no `AskUserQuestion` in this step**. Classify inline: code directly answers question → reclassify `[req]` or `[suggest]` per reviewer intent; answer reveals known limitation or deferred work → keep `[question]` tag, append brief answer note. Unresolvable from code → keep `[question]` unchanged. All `[question]` items flow into Step 3d for user selection — user selecting one there implicitly approves implementation. Never self-promote without code evidence

<!-- oss:resolve Step 3a — executed inline: cat $_OSS_RESOLVE/modes/report-intelligence.md; execute -->

<!-- fragment — no <workflow> wrapper; executed inline by SKILL.md orchestrator -->

<!-- consumer: plugins/cc_oss/skills/resolve/SKILL.md (Step 3a) -->

## Step 3a: Report intelligence (report mode only)

*Skip to Step 3b (PR intelligence) when in pr mode or pr + report mode.*

<!-- Sources block template (used in 3a/3b/3c): fields GitHub and Report vary by mode -->

When mode == **report**:

Source file = `REPORT_FILE`, already resolved and gated by SKILL.md Step 1's **Report source resolution** block: `IFS= read -r REPORT_FILE < "${TMPDIR:-/tmp}/resolve-report-file-${CSID}"`. Never glob for it again here, and never conclude "no report" from an empty sentinel — empty means that block has not run yet; run it, including its `AskUserQuestion` gate when nothing is found. Starting a fresh `oss:review` without that gate is the documented failure this path exists to prevent.

Print Sources block before parsing findings:

```markdown
## Resolve — sources

Mode   : report
PR     : #<N>  (extracted from report header, or "n/a — working on current branch")
GitHub : not fetched
Report : Read <path to report file>

Building action items…
```

<!-- loads: review-section-taxonomy.md -->

```bash
export CSID="${CLAUDE_CODE_SESSION_ID:-$PPID}"
IFS= read -r _OSS_SHARED < "${TMPDIR:-/tmp}/resolve-oss-shared-${CSID}" 2>/dev/null || _OSS_SHARED=""  # reload (Check 41)
cat "$_OSS_SHARED/review-section-taxonomy.md"  # timeout: 5000
```

Taxonomy (loaded above) — use **Grep pattern** row for header matching (contains-match; headers may carry `⚠ LOW CONFIDENCE — ` prefix), **Severity → Resolve Type** table for `type` assignment, **LOW Grouping Rule** for composite rows, **Owner agent** column for `author` field, and **resolve `change`** column for `change` field. Skip sections where Grep key is `— skip`.

- `author`: Owner agent column from taxonomy
- `change`: resolve `change` column from taxonomy — drives Step 8 Phase 2 specialist routing; do NOT default every report item to `code`, the taxonomy row already names the right value per section
- `file`/`line`: extract from `file:line` notation; blank if absent or grouped composite
- `full_comment_text`: full finding bullet (or concatenated bullets for composites)
- All items get `[report]` prefix on `type` (e.g., `[report][req]`, `[report][suggest]`)

Print ACTION_ITEMS as markdown table to terminal (severity descending):

```markdown
### Action Items — report

| # | Type | Change | Severity | Author | Status | Summary | Notes |
|---|------|--------|----------|--------|--------|---------|-------|
| 1 | [report][req] | code | 4 | foundry:sw-engineer | pending | rename param x to count | — |
```

Summary ≤60 chars. Notes = `—` when empty; carries commit SHA for `[done]` rows and classification verdicts (e.g. deprecation filter output) — never `file:line`, which the `file`/`line` fields already hold. Print before branching on PR# presence so user sees all items that get executed (report mode skips Step 3d — no picker).

PR# found in report header → set `$ARGUMENTS = <N>`, go to Step 4; skip Step 3b. After checkout, set `SELECTED_ITEMS` = all report-derived ACTION_ITEMS IDs (report mode executes all findings; no user selection step); skip to Step 8.

No PR# in header → skip Steps 3b and 4; work on current branch as-is. Before skipping, set fallback values for variables Step 8 reads: `HEAD_REF=$(git branch --show-current 2>/dev/null || echo "")` and `IS_FORK=false` (no cross-repo context). Set `SELECTED_ITEMS` = all report-derived ACTION_ITEMS IDs; skip to Step 8.

**Report mode — Step 8 behavior**: `SELECTED_ITEMS` initialized above; Step 3d (user selection) is skipped; Step 8 proceeds with all report-derived items. If report produces zero action items: `SELECTED_ITEMS=[]` → Step 8 skipped, jump to Step 9.

**Challenge Log — Phase 1 not skippable in report mode.** Report-mode items reach Step 8 with `SELECTED_ITEMS` set above, same as any other mode — `action-item-dispatch.md`'s Phase 1 then runs unconditionally; only sanctioned skip is `--no-challenge` (SKILL.md), which omits Challenge Log section entirely. Do not shortcut Phase 1 by reusing a source report's own verdicts or `Recommendation` text as if it were Phase 1 output, even when that source is itself a prior `oss:review` report — a reviewer's own recommendation is exactly the unproven claim Phase 1 exists to independently re-verify (`action-item-dispatch.md`'s Part 1/Part 2 challenge contract). Reusing source verdicts instead of dispatching challenge agents is a spec violation to self-correct on, not a documented report-mode behavior.

**`BASE_REF` derivation (no-PR path)** — when Step 3b skipped (report mode without PR#, or comment-dispatch mode), Step 9's lint-qa gate still needs `BASE_REF` for `git merge-base HEAD "origin/$BASE_REF"`. Without it, `BASE_REF` expands empty → `origin/` invalid ref → linting sees no changes → workflow pushes silently with vacuous QA gate. Set from local default-branch symbolic-ref before Step 8, guard downstream `git merge-base` against shallow-clone empty output (CI checkouts often use `--depth=1`, `merge-base` returns nothing — linting again sees no changes):

```bash
BASE_REF=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's|refs/remotes/origin/||' || echo "main")  # timeout: 3000
# shallow-clone fallback: git merge-base returns empty in --depth=1 clones
# and git diff <empty>..HEAD shows entire branch history (or nothing)
MERGE_BASE=$(git merge-base HEAD "origin/$BASE_REF" 2>/dev/null)  # timeout: 3000
if [ -z "$MERGE_BASE" ]; then
    MERGE_BASE=$(git rev-list --max-parents=0 HEAD 2>/dev/null | head -1)  # timeout: 3000
fi
```

<!-- oss:resolve final report template — read by Step 11 for output format reference -->

<!-- Placeholders: $PR_NUMBER, $PR_URL, $BRANCH, $REPO, $ACTION_ITEMS count, per-item status -->

## Resolve Report — PR #<number>

### Contribution

\<2–3 sentence motivation summary from Step 3b>

### Conflicts

\<conflict table from Step 7, or "No conflicts detected">

### Action Items

<!-- One row per SELECTED item. Columns: # | Type | Change | Status | Resolution | Commit -->

<!-- Status: ✓ implemented / ⊘ skipped / ✗ rejected by challenge -->

<!-- Resolution: implemented / self-resolved / skipped / challenge-rejected -->

<!-- Change: code / test / docs / config / ci / style / refactor -->

<!-- Commit: short SHA or "—" when COMMIT_MODE=stage -->

| # | Type | Change | Status | Resolution | Commit |
| -- | -- | -- | -- | -- | -- |
| 1 | [gh][req] | code | ✓ | implemented | `abc1234` |

### Challenge Log

<!-- One row per surviving/rejected item. Verdicts render as bracketed flags [VALID]/[REJECT] with a mandatory few-word reason — never a bare verdict word. Every cell self-contained — no cross-row lookups needed. Omit section when --no-challenge. -->

| # | Finding | Evidence | Suggestion | Resolution |
| -- | -- | -- | -- | -- |
| 1 | Off-by-one in pagination cursor at api.py:88 | [VALID] — cursor increments before bounds check, confirmed in code | [VALID] — fix matches existing guard pattern used elsewhere in file | as-suggested: moved bounds check before cursor increment (`abc1234`) |
| 9 | Use `cv2.INTER_AREA` for all resizes | [VALID] — current code uses fixed interpolation regardless of scale direction | [REJECT] — unconditional INTER_AREA degrades quality on upscale | self-resolved: use INTER_AREA only when both target dims < source, else INTER_LINEAR |

<!-- ✗ wrong — bare verdict, no reason: | 3 | ... | VALID | VALID | ... | -->

<!-- ✓ right — every verdict cell carries flag + reason, always the Phase 1 challenge agent's actual rationale — never a filler string standing in for a missing one -->

### Lint + QA

\<linting-expert summary: N fixes applied | or "no violations"> / \<foundry:qa-specialist summary: N blocking fixed, N warnings | or "clean">

### Push

✓ Pushed to <remote>/\<HEAD_REF> — N new commits

**Next**:

- Maintainer reviews, clicks Merge in GitHub UI — merge commit keeps per-item commits; squash collapses them

## Confidence

<!-- format per quality-gates.md: Score 0.N, Gaps bullets, Refinements N passes (omit if 0) -->

**Score**: 0.N — [high ≥0.9 | moderate 0.85–0.9 | low \<0.85 ⚠]

**Gaps**:

- [specific limitation]

**Refinements**: N passes.

- Pass 1: [what gap was addressed]