fix(mcp): let a sanctioned recovery keep its own owning PR (Closes #755)

#753 added the dead-session author-lock recovery assessor, but no sanctioned
recovery could ever reach the lock write. A dead-session lock is by construction
a lock for work that already has an open PR, and the #400 duplicate-work gate
blocked unconditionally on any linked open PR. gitea_lock_issue computed
recovery_sanctioned, then discarded it one gate later:

    open PR #750 already covers issue #749 (fail closed)

Because the recovered lock was never persisted, it stayed non-live, so
_prove_author_ownership_for_pr found no live author lock and
gitea_update_pr_branch_by_merge failed closed too. Both blockers had a single
cause, so only the first one is fixed here.

issue_lock_recovery.owning_pr_recovery_evidence distils a granted assessment
into the minimum evidence the duplicate gate needs: issue, branch, owning PR
number, and head. It returns None unless the outcome is RECOVERY_SANCTIONED and
the assessment's own evidence agrees that local head == remote head == PR head,
so a partial or hand-built assessment cannot authorize anything.

The duplicate gate takes that evidence and re-checks every element against the
live PR list it was handed: exactly one linked open PR, matching number, head
branch, head SHA, and locked branch. Only that exact self-owned PR is exempt.
A different PR, several linked PRs, a different branch or head, or evidence for
another issue all keep failing closed, with a diagnostic naming which element
disagreed. The competing-branch, claim-lease and commit/push/create_pr arms are
untouched, and with no evidence the gate behaves exactly as before.

Ownership proof needed no change: once the recovered lock persists under the
live session pid, _prove_author_ownership_for_pr matches it as before.

Out of scope: the PHASE_COMMIT/PHASE_PUSH/PHASE_CREATE_PR rechecks still block
on a linked open PR for every author, recovered or not. That is pre-existing
#400 behavior, unrelated to lock recovery, and #755 does not cover it.

Tests
- tests/test_issue_755_owning_pr_recovery.py (new, 31 tests) drives the real
  mcp_server.gitea_lock_issue handler, not only the pure assessor: sanctioned
  recovery relocks, persists a live lease with truthful dead_session_recovery
  provenance, and satisfies _prove_author_ownership_for_pr; competing PR,
  multiple linked PRs, mismatched head/branch/worktree, dirty worktree, live
  prior pid, and a fresh claim with no prior lock all stay blocked.
- Neutralizing owning_pr_recovery_evidence regresses all three success tests to
  the exact production error above, so the coverage is load-bearing.
- Focused suites (755, 753, duplicate gates, lock registration, provenance) —
  102 passed.
- Lock/ownership/worktree/handoff suites — 172 passed, 16 subtests.
- Full suite tests/ — 3529 passed, 6 skipped, 2 failed, 365 subtests.
- The same 2 failures reproduce on a pristine detached worktree at
  08f67007c5 (3498 passed, 6 skipped, 2 failed):
  test_issue_702_review_findings_f1_f6 F1 recovery-before-probe and
  test_reconciler_supersession_close org/repo forwarding. Pre-existing.
- git diff --check clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_017BNsk3KUuFchaZyPJsCxjk

gitea_mcp_server.py

@@ -2081,6 +2081,7 @@ def _assess_issue_duplicate_gate(
     auth: str,
     locked_branch: str | None = None,
     phase: str,
+    recovered_owning_pr: dict | None = None,
 ) -> dict:
     open_prs, branch_names, claim_entry = _collect_issue_duplicate_context(
         h, o, r, auth, issue_number
@@ -2092,6 +2093,7 @@ def _assess_issue_duplicate_gate(
         claim_entry=claim_entry,
         locked_branch=locked_branch,
         phase=phase,
+        recovered_owning_pr=recovered_owning_pr,
     )
 
 
@@ -3268,6 +3270,17 @@ def gitea_lock_issue(
     recovery_sanctioned = bool(
         recovery_assessment and recovery_assessment.get("recovery_sanctioned")
     )
+    # #755: a sanctioned dead-session recovery always has an owning open PR —
+    # that is what makes it a recovery rather than a fresh claim. Carry the
+    # server-derived owning-PR evidence into the duplicate-work gate below so
+    # the PR this lock already owns is not mistaken for competing duplicate
+    # work. Withheld (None) unless recovery was granted, so the ordinary
+    # duplicate blocker is untouched on every other path.
+    recovered_owning_pr = (
+        issue_lock_recovery.owning_pr_recovery_evidence(recovery_assessment)
+        if recovery_sanctioned
+        else None
+    )
     lock_assessment = issue_lock_worktree.assess_issue_lock_worktree(
         worktree_path=resolved_worktree,
         current_branch=git_state.get("current_branch"),
@@ -3300,6 +3313,7 @@ def gitea_lock_issue(
         auth=auth,
         locked_branch=branch_name,
         phase=issue_work_duplicate_gate.PHASE_LOCK,
+        recovered_owning_pr=recovered_owning_pr,
     )
     if duplicate_gate.get("block"):
         raise ValueError("; ".join(duplicate_gate.get("reasons") or [