Merge pull request 'fix(author): refresh durable issue-lock head after branch sync; recover merge-sync-drifted dead-session locks (Closes #871 )' (#874 ) from fix/issue-871-durable-lock-head-refresh into master

Merge branch 'master' into fix/issue-871-durable-lock-head-refresh
Merge pull request 'docs(governance): MCP restart governance and authorization policy (Closes #656 )' (#857 ) from docs/issue-656-mcp-restart-governance into master
2026-07-24 03:04:24 -05:00 · 2026-07-24 02:42:52 -05:00 · 2026-07-24 02:26:02 -05:00 · 2026-07-24 02:07:17 -05:00 · 2026-07-24 02:56:57 -04:00 · 2026-07-24 01:00:53 -05:00
16 changed files with 5806 additions and 30 deletions
@@ -0,0 +1,223 @@
+# ADR: MCP restart governance and authorization policy
+
+- **Status:** Accepted (policy effective immediately for LLM and operator sessions; enforcement tooling may lag)
+- **Date:** 2026-07-23
+- **Tracking issue:** [#656](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/656)
+- **Policy version:** `restart-governance/v1`
+- **Related:**
+  - Umbrella: [#655](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/655) — governed MCP restart coordination and zero-disruption recovery
+  - Vision: [#652](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/652) — MCP Control Plane Web Console product vision (§A system health and process control)
+  - Roadmap: [#653](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/653) — Control Plane Web Console phased delivery (Phase 2 restart controls)
+  - Contamination guard: [#630](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/630) — blocks manual process-kill recovery
+  - Console restart UX: [#642](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/642) — sanctioned restart and graceful reload
+  - Existing restart / reconnect paths to inventory: [#591](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/591) — auto-restart on master advance (closed); [#584](https://gitea.prgs.cc/Scaled-Tech-Consulting/Gitea-Tools/issues/584) — host auto-reconnect on transport flap
+  - Stable-control runtime split: `docs/architecture/mcp-stable-control-runtime-policy-adr.md` (#615)
+  - Client-namespace health: `docs/mcp-namespace-health.md` (#543)
+  - Reconnect-only EOF recovery: `docs/mcp-namespace-eof-recovery.md`
+
+## 1. Context
+
+The Gitea MCP server is the **control plane** for real issue and PR mutations
+(create, comment, lock, review, merge, reconcile). The same process serves every
+role namespace (`gitea-author`, `gitea-reviewer`, `gitea-merger`,
+`gitea-reconciler`, `gitea-controller`) and holds the in-memory capability-gate
+code loaded at startup.
+
+Restarting that process is destructive to concurrent work:
+
+- It resets every session's identity, preflight, and capability-lease binding.
+- It can interrupt a mutation mid-critical-section (a lock acquire, a review
+  submit, a merge), leaving durable state half-written.
+- Relaunching from the wrong checkout or worktree silently changes which code
+  the control plane runs, defeating master-parity gates (#420 / #615).
+
+Today there is **no durable written policy** stating who may restart MCP, under
+what conditions, that restart is a last resort, and how controller approval,
+automated safety gates, and break-glass interact. Operators and LLM sessions
+therefore invent restart behavior ad hoc, which makes concurrent multi-role work
+unsafe. #630 and #642 need this policy as their backbone.
+
+This ADR defines that policy. It does **not** implement coordinator code or HA
+multi-instance restart (those are later children of #655).
+
+## 2. Decision
+
+### 2.1 v1 decision (recorded)
+
+**Restart authority in v1 is `controller approval + automated safety gates`.**
+
+A restart of the stable control runtime is authorized only when **both** hold:
+
+1. A **controller** role explicitly approves the restart, recording an audit
+   entry (who, why, scope, affected sessions), **and**
+2. The **automated safety gates** pass: a completed drain acknowledgement (no
+   affected session is mid-critical-section) or a declared break-glass incident
+   (§2.5).
+
+Quorum among multiple controllers is **not** required day-one. It is deferred
+unless a later investigation (tracked under #653) proves single-controller
+approval is insufficient. This ADR records the v1 decision so enforcement code
+(#630) has a fixed target; changing it requires a superseding ADR.
+
+### 2.2 Restart is a last resort — the recovery ladder
+
+Restart is the **last** rung. Before any restart, exhaust the narrower
+recoveries, in order:
+
+1. **Reconnect** the IDE/client MCP namespace (transport EOF, `client is
+   closing: EOF`, transient `#584` flap). No process change. See
+   `docs/mcp-namespace-eof-recovery.md`.
+2. **Refresh / rebind** the session workspace: re-run `gitea_whoami`,
+   `gitea_resolve_task_capability`, and pass an explicit validated
+   `worktree_path`. Fixes stale session context without touching the process.
+3. **Scoped restart** of a single misbehaving namespace/service (where the
+   deployment supports per-service restart) rather than the whole control plane.
+4. **Full restart** of the stable control runtime process — operator-owned,
+   controller-approved, drained.
+5. **Host / infrastructure restart** — the broadest action; same authorization
+   as a full restart plus infrastructure ownership.
+
+A session **must** try rungs 1–2 and record why they were insufficient before
+requesting a restart at rung 3 or above. Skipping straight to restart is a
+policy violation.
+
+### 2.3 Authorization matrix
+
+| Role | Reconnect (1) | Refresh/rebind (2) | Scoped restart (3) | Full restart (4) | Host restart (5) |
+|---|---|---|---|---|---|
+| **author** | self | self | request only | **forbidden** | forbidden |
+| **reviewer** | self | self | request only | **forbidden** | forbidden |
+| **merger** | self | self | request only | **forbidden** | forbidden |
+| **reconciler** | self | self | request only | **forbidden** | forbidden |
+| **controller** | self | self | **approve** (+gates) | **approve** (+gates) | request to operator |
+| **operator** | self | self | execute (controller-approved) | execute (controller-approved) | execute (controller-approved) |
+| **admin** | self | self | execute | execute | execute (break-glass) |
+
+Legend: *self* = may perform for its own client session; *request only* = may
+raise a restart request but not authorize or execute it; *approve* = may
+authorize under §2.1 gates; *execute* = may perform the process action after the
+authorization is recorded.
+
+Key invariants:
+
+- **No LLM worker role (author/reviewer/merger/reconciler) may perform or
+  authorize a full or host restart.** They may only reconnect/rebind their own
+  client and file a restart request.
+- **Controller approval authorizes; operator/admin executes.** The approving
+  controller and the executing operator may be the same human, but both the
+  approval and the execution are audited.
+- Privileged process actions (full restart, host restart) are reserved to
+  **operator/admin**, never to an automated worker.
+
+### 2.4 Approved conditions
+
+A restart at rung 3+ is approved only under one of these recorded conditions:
+
+- **No affected sessions:** the control plane has no live session that would be
+  interrupted (verified, not assumed).
+- **Full drain acknowledged:** every affected session has drained
+  (no open critical section — no held mutation lease mid-write) and the drain is
+  acknowledged in the audit record.
+- **Controller + gates:** controller approval plus passing automated safety
+  gates (§2.1), the standard v1 path.
+- **Quorum:** not required in v1; reserved for a future superseding ADR.
+- **Break-glass:** an incident-backed emergency exception (§2.5).
+
+Restart **never** bypasses mutation gates mid-critical-section. Drain before
+restart is mandatory except under break-glass with a declared incident.
+
+### 2.5 Break-glass
+
+Break-glass is a **separate, narrower** authorization path for emergencies where
+the normal drain-and-approve path cannot complete (e.g. the control plane is
+wedged and cannot drain).
+
+Break-glass conditions:
+
+- A declared incident record exists (id, timestamp, declarer) **before** the
+  action.
+- The action is taken by **operator or admin** authority only — never by an LLM
+  worker role, and never unilaterally by an operator with active peers when a
+  controller is reachable.
+- The scope is the minimum necessary rung of the ladder.
+- A **mandatory post-hoc audit** entry is filed: what was restarted, why the
+  normal path was impossible, which sessions were affected, and the incident id.
+
+Break-glass suspends the drain requirement, not the audit requirement.
+
+### 2.6 Explicit prohibitions
+
+- **A unilateral LLM or operator full restart while active peer sessions
+  exist is forbidden.** An LLM worker role must not kill, restart, or relaunch
+  the MCP process; a lone operator must not full-restart over live peer work
+  without controller approval or a break-glass incident.
+- Process-kill recovery is forbidden as a routine tool (#630). This ADR does not
+  introduce a kill path.
+- Ambiguous policy state **denies** restart (§4).
+
+## 3. Security requirements
+
+- Full restart and host restart are **privileged**; only operator/admin execute
+  them, only after a controller approval or break-glass incident is recorded.
+- Break-glass is a distinct authorization path with its own audit mandate; it is
+  never the default and never silent.
+- **Every approval and every restart action is audited** (who approved, who
+  executed, scope, affected sessions, condition, policy version). No restart is
+  authorized without a durable audit entry.
+
+## 4. Failure behavior
+
+**Ambiguous policy → deny restart.** If it cannot be established that a
+restart is authorized under §2 — unknown affected-session state, missing
+controller approval, absent break-glass incident, or an unclassifiable request —
+the safe action is to **refuse** the restart and stop with a recovery report,
+never to restart on assumption.
+
+## 5. Policy IDs (for enforcement code)
+
+Enforcement code — the restart coordinator (a later child of #655), the #630
+contamination guard, and the #642 console restart UX — binds to these stable
+policy identifiers rather than to prose:
+
+| Policy ID | Statement |
+|---|---|
+| `RG-01` | Restart is last resort; rungs 1–2 must be tried and recorded first (§2.2). |
+| `RG-02` | v1 authority = controller approval + automated safety gates (§2.1). |
+| `RG-03` | No LLM worker role performs or authorizes full/host restart (§2.3). |
+| `RG-04` | Full/host restart executed by operator/admin only, post approval (§2.3). |
+| `RG-05` | Drain before restart is mandatory except break-glass with incident (§2.4). |
+| `RG-06` | Break-glass requires a pre-declared incident and post-hoc audit (§2.5). |
+| `RG-07` | Unilateral LLM/operator full restart with active peers is forbidden (§2.6). |
+| `RG-08` | Ambiguous policy state denies restart (§4). |
+
+The `restart-governance/v1` **policy version** field is emitted on future
+restart audit events so approvals can be reconciled against the policy revision
+in force.
+
+## 6. Dogfooding
+
+Gitea-Tools governs its own MCP control plane by this policy. Author, reviewer,
+merger, and reconciler sessions operating on this repository use the recovery
+ladder (§2.2) — reconnect and rebind, never self-restart — and any real restart
+of the Gitea-Tools stable control runtime follows the controller-approval +
+drain path defined here.
+
+## 7. Acceptance and cross-links
+
+This ADR is the authoritative restart-governance policy. It **must** stay
+cross-linked from the safety model and the web-console deployment boundary:
+
+- `docs/safety-model.md` § Process restart governance references this ADR.
+- `docs/webui-deployment.md` references this ADR for restart/reload disposition.
+
+It is linked to its issue lineage — umbrella **#655**, vision **#652**, roadmap
+**#653**, contamination guard **#630**, and console restart UX **#642** — in
+§ Related above.
+
+## 8. Non-goals
+
+- Implementing the restart coordinator or approval state machine (#630, later
+  children of #655).
+- Implementing HA multi-instance restart or quorum machinery.
+- Introducing any process-kill or auto-restart tool; existing auto-restart
+  behavior must be inventoried before any new restart tool is enabled.
@@ -46,3 +46,17 @@ If shell helpers are unavailable and MCP commit cannot run, stop with a recovery
 report (restart session, clear hung terminals, use MCP-native commit). See
 [`llm-workflow-runbooks.md`](llm-workflow-runbooks.md) § MCP-native commit path
 (#260) and agent temp artifact cleanup (#261).
+
+## 7. Process restart governance
+
+Restarting the MCP control-plane process is destructive to concurrent multi-role
+work and is governed by a dedicated policy. Restart is a **last resort** behind
+narrower recoveries (reconnect, rebind), full/host restart is reserved to
+operator/admin under **controller approval + automated safety gates**, a
+unilateral LLM or operator full restart with active peers is **forbidden**, and
+ambiguous policy state **denies** restart. Break-glass is a separate,
+incident-backed path with a mandatory audit.
+
+See [`architecture/mcp-restart-governance.md`](architecture/mcp-restart-governance.md)
+(#656) for the authorization matrix, the recovery ladder, break-glass
+conditions, and the `RG-01`–`RG-08` policy IDs.
@@ -55,6 +55,15 @@ shipped to the browser.
 assumption paths, and the client-secret policy. Use it to verify an instance is
 configured for internal-only operation.

+## Process restart / reload disposition
+
+The console never exposes a restart or reload control; process restart of the
+MCP control-plane runtime is governed separately. Restart is a last resort behind
+reconnect/rebind, full restart is operator/admin-only under controller approval
+plus safety gates, and break-glass is an incident-backed path. See
+[`architecture/mcp-restart-governance.md`](architecture/mcp-restart-governance.md)
+(#656).
+
 ## Non-goals (MVP)

 - Full SSO or session login in the UI
@@ -440,13 +440,32 @@ def _session_author_lock_worktree() -> str | None:

    Used to derive the author mutation workspace when no explicit
    ``worktree_path`` or env binding is provided. Never invents a path.
+
+    #864: a session pointer whose owner PID is dead and is not this process
+    must not force workspace binding for other issues — rebind is required for
+    that issue, and a stale dead-owner pointer must not poison unrelated work.
    """
    try:
        lock = issue_lock_store.read_session_issue_lock() or {}
    except Exception:
        return None
    path = (lock.get("worktree_path") or "").strip()
-    return path or None
+    if not path:
+        return None
+    pid = lock.get("session_pid")
+    if pid is None:
+        pid = lock.get("pid")
+    try:
+        pid_i = int(pid) if pid is not None else None
+    except (TypeError, ValueError):
+        pid_i = None
+    if (
+        pid_i is not None
+        and pid_i != os.getpid()
+        and not issue_lock_store.is_process_alive(pid_i)
+    ):
+        return None
+    return path


 def _resolve_preflight_workspace_path(worktree_path: str | None = None) -> str:
@@ -2031,6 +2050,7 @@ import issue_lock_store  # noqa: E402
 import issue_lock_adoption  # noqa: E402
 import issue_lock_recovery  # noqa: E402
 import issue_lock_renewal  # noqa: E402
+import dirty_same_claimant_session_rebind  # noqa: E402  # #864
 import stacked_pr_support  # noqa: E402
 import merge_approval_gate  # noqa: E402
 import review_quarantine  # noqa: E402  # #695 contaminated formal-review quarantine
@@ -2425,6 +2445,20 @@ def _evaluate_issue_lock_recovery(
            descendant_sha=local_head,
        )

+    # #871: the inverse of the #768 descendant relation — the *remote* head may
+    # have advanced past the local/recorded head via a sanctioned merge-based
+    # branch sync (``gitea_update_pr_branch_by_merge``) while the local worktree
+    # stayed put. Observe that provenance server-side so the assessor can prove
+    # it and nothing else. Probed only when the heads differ; never from any
+    # caller-supplied value.
+    sync_provenance: dict | None = None
+    if remote_head and local_head and remote_head != local_head:
+        sync_provenance = issue_lock_worktree.read_merge_sync_provenance(
+            worktree_path,
+            prior_head_sha=local_head,
+            synced_head_sha=remote_head,
+        )
+
    # #772: with no remote branch there is no head to measure against, so the
    # base the branch was cut from is observed instead. Probed only in that
    # case, so the published path's evidence is untouched (#772 AC8).
@@ -2467,6 +2501,7 @@ def _evaluate_issue_lock_recovery(
        remote_branch_exists=remote_branch_exists,
        recorded_base_sha=recorded_base,
        base_ancestry=base_ancestry,
+        sync_provenance=sync_provenance,
    )


@@ -4342,6 +4377,263 @@ def gitea_lock_issue(
    return result


+@mcp.tool()
+def gitea_rebind_dirty_same_claimant_author_session(
+    issue_number: int,
+    branch_name: str,
+    worktree_path: str,
+    old_pid: int,
+    expected_local_head: str,
+    expected_remote_head: str,
+    expected_dirty_paths: list[str],
+    expected_fingerprints: dict,
+    remote: str = "dadeschools",
+    host: str | None = None,
+    org: str | None = None,
+    repo: str | None = None,
+    dry_run: bool = False,
+    authorize_reconciler_execute: bool = False,
+) -> dict:
+    """Rebind a dirty registered issue worktree to this session (#864).
+
+    Sanctioned only when every pin agrees: same claimant, dead old_pid matching
+    the durable lock, matching local/remote heads, exact dirty path set, and
+    per-path sha256 fingerprints. Preserves every tracked/untracked byte.
+    Does not sync remote, create recovery worktrees, clean, reset, or move heads.
+
+    Role gate:
+    * author — must match the lock claimant identity/profile
+    * reconciler — execute only when ``authorize_reconciler_execute=True``
+    * reviewer/merger — always refuse
+
+    ``gitea.issue.comment`` (author map entry) is required for mutation; dry_run
+    still assesses fully but writes nothing. Permission alone is never ownership
+    proof — every pin is re-checked server-side.
+
+    Args:
+        issue_number: Tracking issue number on the durable lock.
+        branch_name: Exact locked branch name.
+        worktree_path: Registered dirty worktree path (must be under branches/).
+        old_pid: Dead owner PID recorded on the lock (must match session_pid/pid).
+        expected_local_head: Full local HEAD sha the caller observed.
+        expected_remote_head: Full remote-tracking HEAD sha the caller observed.
+        expected_dirty_paths: Exact set of dirty relative paths (tracked+untracked).
+        expected_fingerprints: Map of relative path -> sha256 hex of file bytes.
+        remote: Known instance — 'dadeschools' or 'prgs'.
+        host/org/repo: Optional target overrides (validated against binding).
+        dry_run: When true, assess only (no lock/session writes).
+        authorize_reconciler_execute: Reconciler-only execute gate.
+    """
+    role = _profile_role_kind(get_profile())
+    role_norm = (role or "").strip().lower()
+
+    # Permission: authors need comment; dry_run assess is reachable under read
+    # for diagnosis, but execute always needs comment. Reconciler execute also
+    # needs comment when authorized.
+    if dry_run:
+        read_block = _profile_operation_gate("gitea.read")
+        if read_block:
+            return {
+                "success": False,
+                "dry_run": True,
+                "reasons": read_block,
+                "permission_report": _permission_block_report("gitea.read"),
+            }
+    else:
+        blocked = _profile_permission_block(
+            task_capability_map.required_permission(
+                "rebind_dirty_same_claimant_author_session"
+            ),
+            issue_number=issue_number,
+            remote=remote,
+            host=host,
+            org=org,
+            repo=repo,
+            org_explicit=org is not None,
+            repo_explicit=repo is not None,
+        )
+        if blocked:
+            return blocked
+
+    if role_norm in {"reviewer", "merger"}:
+        return {
+            "success": False,
+            "dry_run": bool(dry_run),
+            "outcome": dirty_same_claimant_session_rebind.REFUSED,
+            "reasons": [
+                f"role '{role_norm}' cannot rebind dirty same-claimant author "
+                "sessions (fail closed)"
+            ],
+        }
+    if role_norm == "reconciler" and not authorize_reconciler_execute and not dry_run:
+        return {
+            "success": False,
+            "dry_run": False,
+            "outcome": dirty_same_claimant_session_rebind.REFUSED,
+            "reasons": [
+                "reconciler role requires authorize_reconciler_execute=True "
+                "to execute dirty same-claimant rebind (fail closed)"
+            ],
+        }
+
+    h, o, r = _resolve(remote, host, org, repo)
+    try:
+        identity = _authenticated_username(h)
+    except Exception:
+        identity = None
+    profile = get_profile()
+    profile_name = profile.get("profile_name")
+
+    existing = _load_existing_issue_lock(
+        remote=remote, org=o, repo=r, issue_number=issue_number
+    )
+    resolved_wt = os.path.realpath(os.path.abspath((worktree_path or "").strip()))
+    inv = dirty_same_claimant_session_rebind.collect_dirty_inventory(resolved_wt)
+
+    branch_res = subprocess.run(
+        ["git", "-C", resolved_wt, "branch", "--show-current"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    current_branch = (branch_res.stdout or "").strip() or None
+    head_res = subprocess.run(
+        ["git", "-C", resolved_wt, "rev-parse", "HEAD"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    local_head = (head_res.stdout or "").strip() if head_res.returncode == 0 else None
+
+    # Observe remote-tracking head without network when possible.
+    remote_head = None
+    for ref in (
+        f"refs/remotes/origin/{branch_name}",
+        f"origin/{branch_name}",
+        f"refs/remotes/{remote}/{branch_name}",
+        f"{remote}/{branch_name}",
+    ):
+        rh = subprocess.run(
+            ["git", "-C", resolved_wt, "rev-parse", "--verify", "--quiet", ref],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if rh.returncode == 0 and (rh.stdout or "").strip():
+            remote_head = (rh.stdout or "").strip()
+            break
+    if remote_head is None:
+        # Fall back to caller's pin only for observation absence — assessment
+        # still requires pin==observed, so missing observation fails closed.
+        remote_head = None
+
+    # Competing live locks (other issues / other worktrees).
+    competing_live = []
+    for entry in issue_lock_store.list_live_locks():
+        competing_live.append(entry)
+
+    # Session pointers that claim this issue lock.
+    competing_sessions = []
+    lock_dir = issue_lock_store.default_lock_dir()
+    lock_path = issue_lock_store.lock_file_path(
+        remote=remote, org=o, repo=r, issue_number=issue_number, lock_dir=lock_dir
+    )
+    try:
+        for name in os.listdir(lock_dir):
+            if not name.startswith("session-") or not name.endswith(".json"):
+                continue
+            ptr = issue_lock_store.read_lock_file(os.path.join(lock_dir, name))
+            if not ptr:
+                continue
+            ptr_lock = str(ptr.get("lock_file_path") or "").strip()
+            if not ptr_lock:
+                continue
+            try:
+                same = os.path.realpath(ptr_lock) == os.path.realpath(lock_path)
+            except OSError:
+                same = ptr_lock == lock_path
+            if not same:
+                continue
+            try:
+                sess_pid = int(str(name)[len("session-") : -len(".json")])
+            except ValueError:
+                sess_pid = ptr.get("pid")
+            competing_sessions.append(
+                {
+                    "pid": sess_pid,
+                    "lock_file_path": ptr_lock,
+                    "live": issue_lock_store.is_process_alive(sess_pid),
+                }
+            )
+    except OSError:
+        pass
+
+    # Best-effort workflow-lease scan: any live lock file whose work_lease is a
+    # non-author workflow lease on this issue/branch counts as active.
+    workflow_lease_active = False
+    for path in issue_lock_store.iter_lock_files(lock_dir):
+        rec = issue_lock_store.read_lock_file(path)
+        if not rec:
+            continue
+        lease = rec.get("work_lease") if isinstance(rec.get("work_lease"), dict) else {}
+        op = str(lease.get("operation_type") or "")
+        if op and op != issue_lock_store.AUTHOR_ISSUE_WORK_LEASE:
+            if rec.get("issue_number") == issue_number or str(
+                rec.get("branch_name") or ""
+            ) == branch_name:
+                if issue_lock_store.is_lease_live(rec):
+                    workflow_lease_active = True
+                    break
+
+    repo_root = _canonical_local_git_root()
+    # permission_allowed reflects profile gate only — never ownership proof.
+    permission_allowed = True
+
+    result = dirty_same_claimant_session_rebind.apply_dirty_same_claimant_session_rebind(
+        remote=remote,
+        org=o,
+        repo=r,
+        issue_number=issue_number,
+        branch_name=branch_name,
+        worktree_path=resolved_wt,
+        claimant_identity=identity,
+        claimant_profile=profile_name,
+        old_pid=old_pid,
+        expected_local_head=expected_local_head,
+        expected_remote_head=expected_remote_head,
+        expected_dirty_paths=list(expected_dirty_paths or []),
+        expected_fingerprints=dict(expected_fingerprints or {}),
+        existing_lock=existing,
+        current_identity=identity,
+        current_profile=profile_name,
+        role_kind=role_norm or role,
+        current_pid=os.getpid(),
+        current_branch=current_branch,
+        local_head=local_head,
+        remote_head=remote_head,
+        dirty_inventory=inv,
+        competing_live_locks=competing_live,
+        competing_sessions=competing_sessions,
+        workflow_lease_active=workflow_lease_active,
+        authorize_reconciler_execute=bool(authorize_reconciler_execute),
+        permission_allowed=permission_allowed,
+        repo_root=repo_root,
+        dry_run=bool(dry_run),
+        lock_dir=lock_dir,
+    )
+    result["observed"] = {
+        "local_head": local_head,
+        "remote_head": remote_head,
+        "current_branch": current_branch,
+        "dirty_paths": inv.get("dirty_paths"),
+        "fingerprints": inv.get("fingerprints"),
+        "identity": identity,
+        "profile": profile_name,
+        "role_kind": role_norm,
+    }
+    return result
+
+
@mcp.tool()
 def gitea_assess_work_issue_duplicate(
    issue_number: int,
@@ -11634,6 +11926,7 @@ def gitea_audit_worktree_cleanup(
    org: str | None = None,
    repo: str | None = None,
    ttl_hours: float = worktree_cleanup_audit.DEFAULT_TTL_HOURS,
+    merged_pr_limit: int = 200,
 ) -> dict:
    """Read-only: classify every session-owned worktree under ``branches/`` (#401).

@@ -11644,17 +11937,26 @@ def gitea_audit_worktree_cleanup(
    the active issue-lock branch is read from the local lock file and treated
    as active work. Deletes nothing and mutates no Gitea state.

-    Fails closed if the live open-PR list cannot be fetched: without it,
-    removability cannot be proven, so no candidates are returned.
+    Merged PRs are fetched as well, so an issue worktree can be linked to the
+    PR that owns its branch (#858). Such a worktree only becomes removable
+    when that owning PR is unambiguous and merged, the worktree head is
+    already contained in authoritative master, and nothing else protects it —
+    no open or competing PR, lease, issue lock, live session, dirty file, or
+    protected/control checkout. Anything unproven keeps it classified as
+    active issue work.
+
+    Fails closed if the live open-PR list, the merged-PR list, or the
+    control-plane lease state cannot be read: without them removability
+    cannot be proven, so no candidates are returned.

    Args:
        remote: Known instance — 'dadeschools' or 'prgs'.
        host: Override the Gitea host.
        org: Override the owner/organization.
        repo: Override the repository name.
-        ttl_hours: Age (hours) after which a clean issue/conflict-fix
-            worktree becomes stale-removable (default from
-            GITEA_WORKTREE_TTL_HOURS).
+        ttl_hours: Age (hours) after which a clean conflict-fix worktree
+            becomes stale-removable (default from GITEA_WORKTREE_TTL_HOURS).
+        merged_pr_limit: Max closed PRs scanned for merged-PR ownership.

    Returns:
        dict with per-worktree classifications, counts, removable
@@ -11690,22 +11992,84 @@ def gitea_audit_worktree_cleanup(
        if (pr.get("head") or {}).get("ref")
    }

+    # #858: merged PRs are the ownership evidence that lets a landed issue
+    # worktree stop being reported as active work. Without them the audit can
+    # never agree with the PR-scoped reconciler, so treat a fetch failure the
+    # same way an open-PR fetch failure is treated: fail closed.
+    try:
+        closed_prs = api_get_all(
+            f"{repo_api_url(h, o, r)}/pulls?state=closed", auth, limit=merged_pr_limit
+        )
+    except Exception as exc:
+        return {
+            "success": False,
+            "performed": False,
+            "open_pr_state_verified": True,
+            "merged_pr_state_verified": False,
+            "reasons": [
+                "could not fetch merged PRs; worktree ownership unverified "
+                f"(fail closed): {_redact(str(exc))}"
+            ],
+        }
+    merged_prs = [pr for pr in closed_prs if (pr.get("merged") or pr.get("merged_at"))]
+    pr_index = worktree_cleanup_audit.build_pr_index(list(open_prs) + merged_prs)
+
+    # #858: the auditor already accepted lease evidence but nothing ever
+    # supplied it, so every worktree looked unleased. Removability is now
+    # reachable for issue worktrees, so authoritative control-plane leases
+    # must be readable or the audit fails closed.
+    db, lease_errs = _control_plane_db_or_error()
+    if db is None:
+        return {
+            "success": False,
+            "performed": False,
+            "open_pr_state_verified": True,
+            "merged_pr_state_verified": True,
+            "lease_state_verified": False,
+            "reasons": [
+                "could not read control-plane leases; worktree protection "
+                "unverified (fail closed)",
+                *lease_errs,
+            ],
+        }
+    lease_result = lease_lifecycle.list_active_leases(
+        db, remote=remote, org=o, repo=r, include_non_active=False, limit=500
+    )
+    leased_issue_numbers: set[int] = set()
+    live_session_paths: set[str] = set()
+    for lease in lease_result.get("leases") or []:
+        if lease.get("work_kind") == "issue" and lease.get("work_number") is not None:
+            try:
+                leased_issue_numbers.add(int(lease["work_number"]))
+            except (TypeError, ValueError):
+                pass
+        if lease.get("worktree_path"):
+            live_session_paths.add(str(lease["worktree_path"]))
+
    active_issue_branches: set[str] = set()
    lock = merged_cleanup_reconcile.read_issue_lock(ISSUE_LOCK_FILE)
    if lock and lock.get("branch_name"):
        active_issue_branches.add(str(lock["branch_name"]).strip())

+    master_ref = f"{remote}/master" if remote in REMOTES else "origin/master"
    report = worktree_cleanup_audit.audit_branches_directory(
        _canonical_local_git_root(),
        open_pr_branches=open_pr_branches,
        active_issue_branches=active_issue_branches,
        now=datetime.now(timezone.utc),
        ttl_hours=ttl_hours,
+        pr_index=pr_index,
+        leased_issue_numbers=leased_issue_numbers,
+        live_session_paths=live_session_paths,
+        master_ref=master_ref,
    )
    return {
        "success": True,
        "performed": False,
        "open_pr_state_verified": True,
+        "merged_pr_state_verified": True,
+        "lease_state_verified": True,
+        "master_ref": master_ref,
        "task_mode": "work-issue",
        **report,
    }
@@ -18540,10 +18904,59 @@ def gitea_update_pr_branch_by_merge(
        prepared_verdict_head_sha=live_pr_head,
    )

-    return {
-        "success": True,
+    # #871: the remote head is now advanced; the durable linked-issue lock must
+    # be advanced with it, or a later dead-session recovery can never prove
+    # ownership at the new head. This runs AFTER the successful remote update, so
+    # a failure here is a *partial* lifecycle failure — the remote moved but the
+    # durable state did not — and must never be reported as a full success.
+    claimant = _work_lease_claimant(h)
+    matched_issue = ownership.get("matched_issue")
+    synced_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    lock_refresh: dict = {
+        "refreshed": False,
+        "reasons": ["durable lock head refresh was not attempted"],
+    }
+    if new_head and matched_issue and source_branch and (wt or None):
+        try:
+            lock_refresh = issue_lock_store.apply_durable_lock_head_refresh(
+                remote=remote,
+                org=o,
+                repo=r,
+                issue_number=int(matched_issue),
+                branch_name=source_branch,
+                worktree_path=wt,
+                pr_number=pr_number,
+                identity=claimant.get("username"),
+                profile=claimant.get("profile"),
+                current_pid=os.getpid(),
+                expected_old_head=live_pr_head,
+                new_head=new_head,
+                synced_at=synced_at,
+                base_head=live_base_head,
+            )
+        except Exception as exc:
+            lock_refresh = {
+                "refreshed": False,
+                "reasons": [
+                    f"durable lock head refresh raised (fail closed): {_redact(str(exc))}"
+                ],
+            }
+    else:
+        lock_refresh = {
+            "refreshed": False,
+            "reasons": [
+                "durable lock head refresh could not run: missing new head, "
+                "linked issue, source branch, or worktree binding"
+            ],
+        }
+
+    durable_refreshed = bool(lock_refresh.get("refreshed"))
+    base_result = {
        "performed": True,
        "mutation_allowed": True,
+        "durable_lock_refreshed": durable_refreshed,
+        "durable_lock_refresh": lock_refresh,
+        "fully_synchronized": durable_refreshed,
        "style": "merge",
        "force_push": False,
        "rebase": False,
@@ -18565,19 +18978,37 @@ def gitea_update_pr_branch_by_merge(
        "prepared_verdict_invalidated": transition.get(
            "prepared_verdict_invalidated"
        ),
-        "recommended_next_action": transition.get(
-            "recommended_next_action",
-            pr_sync_status.ACTION_FRESH_REVIEW_REQUIRED,
-        ),
        "transition": transition,
        "role_kind": role,
        "profile_name": profile.get("profile_name"),
        "worktree_path": wt or None,
-        "reasons": list(transition.get("reasons") or []) + [
-            "update-by-merge completed via native Gitea API (style=merge only)"
-        ],
    }

+    if durable_refreshed:
+        base_result["success"] = True
+        base_result["recommended_next_action"] = transition.get(
+            "recommended_next_action",
+            pr_sync_status.ACTION_FRESH_REVIEW_REQUIRED,
+        )
+        base_result["reasons"] = list(transition.get("reasons") or []) + [
+            "update-by-merge completed via native Gitea API (style=merge only)",
+            f"durable linked-issue lock #{matched_issue} head refreshed to "
+            f"{new_head} (verified by read-after-write)",
+        ]
+        return base_result
+
+    # Partial lifecycle failure: the remote advanced but the durable lock did
+    # not. Do NOT report a fully successful synchronization (#871).
+    base_result["success"] = False
+    base_result["partial_lifecycle_failure"] = True
+    base_result["recommended_next_action"] = pr_sync_status.ACTION_BLOCKED
+    base_result["reasons"] = list(lock_refresh.get("reasons") or []) + [
+        f"PARTIAL LIFECYCLE FAILURE: PR #{pr_number} remote head advanced to "
+        f"{new_head} but the durable linked-issue lock head was not refreshed; "
+        "the synchronization is NOT complete",
+    ]
+    return base_result
+

@mcp.tool()
 def gitea_assess_conflict_fix_push(
@@ -16,11 +16,16 @@ ISSUE_LOCK_FILE = os.environ.get("GITEA_ISSUE_LOCK_FILE", "/tmp/gitea_issue_lock
 SOURCE_LOCK_ISSUE = "gitea_lock_issue"
 SOURCE_LOCK_ADOPTION = "gitea_lock_issue_adoption"
 SOURCE_OPERATOR_OVERRIDE = "operator_override"
+# #864: dirty-preserving same-claimant author-session rebind (dead owner PID).
+SOURCE_DIRTY_SAME_CLAIMANT_REBIND = (
+    "gitea_rebind_dirty_same_claimant_author_session"
+)

 SANCTIONED_LOCK_SOURCES = frozenset({
    SOURCE_LOCK_ISSUE,
    SOURCE_LOCK_ADOPTION,
    SOURCE_OPERATOR_OVERRIDE,
+    SOURCE_DIRTY_SAME_CLAIMANT_REBIND,
 })

 _OPERATOR_OVERRIDE_ENV = "GITEA_ISSUE_LOCK_OPERATOR_OVERRIDE"
@@ -85,6 +85,12 @@ HEAD_RELATION_STRICT_DESCENDANT = "strict_descendant"
 # #772: an unpublished claim has no recorded head to compare against at all, so
 # its head is measured against the base the branch was cut from instead.
 HEAD_RELATION_DESCENDS_FROM_BASE = "descends_from_recorded_base"
+# #871: the remote/PR head advanced *past* the recorded head via a sanctioned
+# merge-based branch synchronization (``gitea_update_pr_branch_by_merge``) while
+# the local worktree stayed at the recorded head. This is the inverse of the
+# #768 descendant relation — here the *remote* strictly descends the local head,
+# and only because a base was merged into the branch, proven server-side.
+HEAD_RELATION_REMOTE_MERGE_SYNCED = "remote_merge_synced"

 # Which body of evidence a recovery was decided on (#772 AC10). These are not
 # interchangeable: a published claim proves ownership against a remote/PR head,
@@ -266,6 +272,70 @@ def _assess_base_descendancy(
    ]


+def _assess_remote_merge_synced(
+    sync_provenance: Mapping[str, Any] | None,
+    *,
+    recorded_head: str,
+    remote_head: str,
+) -> tuple[bool, list[str]]:
+    """Did ``remote_head`` advance past ``recorded_head`` via a sanctioned
+    merge-based branch sync (#871)?
+
+    ``sync_provenance`` is the server-side git observation from
+    ``issue_lock_worktree.read_merge_sync_provenance``. Its own
+    ``prior_head_sha`` / ``synced_head_sha`` are re-checked against the heads
+    this assessment is actually reasoning about, so an observation taken for some
+    other pair of commits — stale, mismatched, or hand-built — can never
+    authorize recovery. This is the inverse of ``_assess_strict_descendant``: the
+    recorded head is the ancestor and the *remote* head is the descendant, and it
+    is accepted only because the remote head is a base-into-branch merge that
+    preserved the branch mainline back to the recorded head.
+
+    Returns ``(proven, notes)``. Notes name the exact missing element so a
+    refused caller sees why, never a bare "unproven".
+    """
+    if not isinstance(sync_provenance, Mapping):
+        return False, [
+            "no server-derived merge-sync provenance observation was available; a "
+            "remote head ahead of the recorded head cannot be accepted"
+        ]
+
+    probe_prior = _text(sync_provenance.get("prior_head_sha"))
+    probe_synced = _text(sync_provenance.get("synced_head_sha"))
+    if probe_prior != recorded_head or probe_synced != remote_head:
+        return False, [
+            f"merge-sync observation covers {probe_prior or 'unknown'} -> "
+            f"{probe_synced or 'unknown'}, not the heads under assessment "
+            f"({recorded_head} -> {remote_head})"
+        ]
+    if not sync_provenance.get("probe_ok"):
+        return False, (
+            list(sync_provenance.get("reasons") or [])
+            or ["merge-sync provenance probe did not complete; provenance unproven"]
+        )
+    if not sync_provenance.get("prior_is_ancestor"):
+        return False, [
+            f"recorded head {recorded_head} is not an ancestor of remote head "
+            f"{remote_head}; a rewritten or force-moved head cannot be recovered"
+        ]
+    if not sync_provenance.get("is_merge_sync"):
+        return False, (
+            list(sync_provenance.get("reasons") or [])
+            or [
+                f"remote head {remote_head} is not a sanctioned merge-based sync "
+                f"of the base into the branch above {recorded_head}"
+            ]
+        )
+
+    proof = _text(sync_provenance.get("proof")) or (
+        f"{remote_head} merged the base into the branch above {recorded_head}"
+    )
+    return True, [
+        f"remote head {remote_head} advanced past recorded head {recorded_head} "
+        f"via a sanctioned merge-based branch sync ({proof})"
+    ]
+
+
 def assess_dead_session_lock_recovery(
    existing_lock: Mapping[str, Any] | None,
    *,
@@ -290,6 +360,7 @@ def assess_dead_session_lock_recovery(
    remote_branch_exists: bool | None = None,
    recorded_base_sha: str | None = None,
    base_ancestry: Mapping[str, Any] | None = None,
+    sync_provenance: Mapping[str, Any] | None = None,
 ) -> dict[str, Any]:
    """Decide whether a dead-session author lock may be natively recovered.

@@ -469,19 +540,39 @@ def assess_dead_session_lock_recovery(
                    head_relation = HEAD_RELATION_STRICT_DESCENDANT
                    ancestry_proof = notes[0] if notes else None
                else:
-                    reasons.append(
-                        f"local head {local_head} does not match remote branch head "
-                        f"{remote_head}"
+                    # #871: the reverse relation — the remote head advanced past
+                    # the recorded/local head via a sanctioned merge-based branch
+                    # sync while the local worktree stayed put. Accepted only on
+                    # server-proven merge-sync provenance, never a caller claim.
+                    synced, sync_notes = _assess_remote_merge_synced(
+                        sync_provenance,
+                        recorded_head=local_head,
+                        remote_head=remote_head,
                    )
-                    reasons.extend(notes)
+                    if synced:
+                        head_relation = HEAD_RELATION_REMOTE_MERGE_SYNCED
+                        ancestry_proof = sync_notes[0] if sync_notes else None
+                    else:
+                        reasons.append(
+                            f"local head {local_head} does not match remote branch "
+                            f"head {remote_head}"
+                        )
+                        reasons.extend(notes)
+                        reasons.extend(sync_notes)
    evidence["recorded_base"] = recorded_base or None
    evidence["local_head"] = local_head or None
    evidence["remote_head"] = remote_head or None
    # ``recorded_head`` is the head recovery is being measured against;
    # ``accepted_head`` is the head this recovery actually adopts. They differ
    # only in the descendant case, and downstream gates need both (#768 AC2/AC7).
+    # #871: in the merge-sync case the branch/PR already carries the synced
+    # remote head, so that is the head recovery adopts; the local worktree stays
+    # at the ancestor recorded head.
    evidence["recorded_head"] = remote_head or None
-    evidence["accepted_head"] = local_head or None
+    if head_relation == HEAD_RELATION_REMOTE_MERGE_SYNCED:
+        evidence["accepted_head"] = remote_head or None
+    else:
+        evidence["accepted_head"] = local_head or None
    evidence["head_relation"] = head_relation
    evidence["ancestry_proof"] = ancestry_proof

@@ -493,12 +584,17 @@ def assess_dead_session_lock_recovery(
        # contradictory; re-stating it as a head mismatch would only obscure why.
        if not unpublished and local_head and pr_head != local_head:
            # A descendant recovery has not been published yet, so the open PR
-            # legitimately still points at the recorded head. Any other
-            # disagreement is a real mismatch.
+            # legitimately still points at the recorded head. A merge-sync
+            # recovery's PR legitimately sits at the advanced remote head. Any
+            # other disagreement is a real mismatch.
            if not (
                head_relation == HEAD_RELATION_STRICT_DESCENDANT
                and remote_head
                and pr_head == remote_head
+            ) and not (
+                head_relation == HEAD_RELATION_REMOTE_MERGE_SYNCED
+                and remote_head
+                and pr_head == remote_head
            ):
                reasons.append(
                    f"open PR #{pr_number} head {pr_head} does not match local head "
@@ -619,7 +715,11 @@ def assess_dead_session_lock_recovery(
        )
    if (
        head_relation
-        in (HEAD_RELATION_STRICT_DESCENDANT, HEAD_RELATION_DESCENDS_FROM_BASE)
+        in (
+            HEAD_RELATION_STRICT_DESCENDANT,
+            HEAD_RELATION_DESCENDS_FROM_BASE,
+            HEAD_RELATION_REMOTE_MERGE_SYNCED,
+        )
        and ancestry_proof
    ):
        proof.append(ancestry_proof)
@@ -697,6 +797,16 @@ def owning_pr_recovery_evidence(
            return None
        if accepted_head != local_head:
            return None
+    elif relation == HEAD_RELATION_REMOTE_MERGE_SYNCED:
+        # #871: the PR already sits at the advanced remote head; the local
+        # worktree is the ancestor the merge preserved. The head the open PR
+        # shows and the head recovery adopts are both the synced remote head.
+        if not remote_head or pr_head != remote_head:
+            return None
+        if accepted_head != remote_head:
+            return None
+        if not local_head or local_head == remote_head:
+            return None
    else:
        return None
    try:
@@ -765,6 +875,18 @@ def recovered_owning_pr_from_lock(
            return None
        if not accepted_head or accepted_head == recorded_head:
            return None
+    elif relation == HEAD_RELATION_REMOTE_MERGE_SYNCED:
+        # #871: PR sits at the advanced remote head, which is both the recorded
+        # measured-against head and the adopted head; the local worktree is the
+        # ancestor the merge preserved.
+        remote_head = _text(record.get("remote_head"))
+        local_head = _text(record.get("local_head"))
+        if not remote_head or pr_head != remote_head:
+            return None
+        if accepted_head and accepted_head != remote_head:
+            return None
+        if not local_head or local_head == remote_head:
+            return None
    else:
        return None
    try:
@@ -738,3 +738,307 @@ def format_lock_proof(
    elif released is False:
        parts.append("lock retained")
    return "; ".join(parts)
+
+
+# ── #871: durable linked-issue lock head refresh after branch synchronization ──
+_FULL_SHA_RE = re.compile(r"^[0-9a-f]{40}$", re.IGNORECASE)
+
+# Provenance recorded on the lock when the head is refreshed by a sanctioned
+# merge-based branch synchronization (``gitea_update_pr_branch_by_merge``).
+LOCK_HEAD_REFRESH_PROVENANCE_MERGE_SYNC = "gitea_update_pr_branch_by_merge"
+
+
+def _norm_sha(value: Any) -> str | None:
+    text = str(value or "").strip().lower()
+    return text if _FULL_SHA_RE.match(text) else None
+
+
+def _lock_claimant_view(lock: dict[str, Any] | None) -> dict[str, Any]:
+    if not isinstance(lock, dict):
+        return {}
+    claimant = lock.get("claimant")
+    if not isinstance(claimant, dict):
+        lease = lock.get("work_lease")
+        claimant = lease.get("claimant") if isinstance(lease, dict) else None
+    return dict(claimant) if isinstance(claimant, dict) else {}
+
+
+def assess_durable_lock_head_refresh(
+    existing_lock: dict[str, Any] | None,
+    *,
+    remote: str,
+    org: str,
+    repo: str,
+    issue_number: int,
+    branch_name: str,
+    worktree_path: str,
+    pr_number: int | None,
+    identity: str | None,
+    profile: str | None,
+    current_pid: int | None,
+    expected_old_head: str | None,
+    new_head: str | None,
+    base_head: str | None = None,
+) -> dict[str, Any]:
+    """Fail-closed assessment for refreshing a durable lock's recorded head (#871).
+
+    A successful ``gitea_update_pr_branch_by_merge`` advances the *remote* PR head
+    but must also advance the durable linked-issue lock so a later dead-session
+    recovery can prove ownership. This decides whether that refresh is permitted;
+    it mutates nothing.
+
+    Every element of durable ownership is re-verified against the persisted lock —
+    repository, issue, branch, worktree, claimant identity/profile, and the live
+    owning session — and the recorded head is compare-and-swapped: the lock's
+    currently recorded synced head (if any) must equal ``expected_old_head``, so a
+    lock whose head or provenance changed concurrently is never overwritten.
+    """
+    reasons: list[str] = []
+    old = _norm_sha(expected_old_head)
+    new = _norm_sha(new_head)
+    evidence: dict[str, Any] = {
+        "issue_number": issue_number,
+        "branch_name": branch_name,
+        "worktree_path": worktree_path,
+        "pr_number": pr_number,
+        "expected_old_head": old,
+        "new_head": new,
+        "base_head": _norm_sha(base_head),
+    }
+
+    if not isinstance(existing_lock, dict) or not existing_lock:
+        reasons.append("no durable lock exists for this issue; nothing to refresh")
+        return {"allowed": False, "reasons": reasons, "evidence": evidence,
+                "expected_generation": 0}
+
+    lock = dict(existing_lock)
+    evidence["current_generation"] = lock_generation(lock)
+
+    if lock.get("issue_number") != issue_number:
+        reasons.append(
+            f"durable lock targets issue #{lock.get('issue_number')}, not "
+            f"#{issue_number}; refusing head refresh"
+        )
+
+    for field, expected in (("remote", remote), ("org", org), ("repo", repo)):
+        actual = str(lock.get(field) or "").strip()
+        if actual != str(expected or "").strip():
+            reasons.append(
+                f"lock {field} '{actual}' does not match requested "
+                f"'{str(expected or '').strip()}'"
+            )
+
+    locked_branch = str(lock.get("branch_name") or "").strip()
+    if locked_branch != str(branch_name or "").strip():
+        reasons.append(
+            f"lock branch '{locked_branch}' does not match requested "
+            f"'{str(branch_name or '').strip()}'"
+        )
+
+    locked_worktree = str(lock.get("worktree_path") or "").strip()
+    try:
+        same_wt = bool(locked_worktree) and bool(worktree_path) and (
+            os.path.realpath(locked_worktree) == os.path.realpath(worktree_path)
+        )
+    except OSError:
+        same_wt = locked_worktree == (worktree_path or "")
+    if not same_wt:
+        reasons.append(
+            f"lock worktree '{locked_worktree}' does not match declared "
+            f"'{str(worktree_path or '').strip()}'"
+        )
+
+    claimant = _lock_claimant_view(lock)
+    locked_identity = str(claimant.get("username") or "").strip()
+    locked_profile = str(claimant.get("profile") or "").strip()
+    if not locked_identity or not locked_profile:
+        reasons.append(
+            "durable lock does not record a claimant identity/profile; "
+            "ownership could not be proven for head refresh"
+        )
+    if not str(identity or "").strip() or not str(profile or "").strip():
+        reasons.append(
+            "active session identity/profile is unknown; ownership could not be "
+            "proven for head refresh"
+        )
+    if locked_identity and str(identity or "").strip() and locked_identity != str(identity).strip():
+        reasons.append(
+            f"lock claimant '{locked_identity}' does not match active identity "
+            f"'{str(identity).strip()}'"
+        )
+    if locked_profile and str(profile or "").strip() and locked_profile != str(profile).strip():
+        reasons.append(
+            f"lock profile '{locked_profile}' does not match active profile "
+            f"'{str(profile).strip()}'"
+        )
+
+    # The refresh is written by the LIVE owning author session. A refresh is not
+    # a recovery: the current process must be the recorded owner.
+    recorded_pid = lock.get("session_pid")
+    if recorded_pid is None:
+        recorded_pid = lock.get("pid")
+    evidence["recorded_pid"] = recorded_pid
+    evidence["current_pid"] = current_pid
+    if current_pid is None:
+        reasons.append("current session pid is unknown; cannot prove live ownership")
+    else:
+        try:
+            if recorded_pid is None or int(recorded_pid) != int(current_pid):
+                reasons.append(
+                    f"durable lock is owned by pid {recorded_pid}, not the current "
+                    f"session pid {current_pid}; head refresh requires the live owner"
+                )
+        except (TypeError, ValueError):
+            reasons.append(
+                "durable lock owner pid is malformed; cannot prove live ownership"
+            )
+
+    if not old:
+        reasons.append("expected_old_head is not a full 40-char hex SHA (fail closed)")
+    if not new:
+        reasons.append("new_head is not a full 40-char hex SHA (fail closed)")
+    if old and new and old == new:
+        reasons.append(
+            "new head equals the expected old head; a sync must advance the head"
+        )
+
+    # Compare-and-swap on the recorded head: if the lock already records a synced
+    # head it must be exactly the expected old head, else another sync moved it.
+    recorded_synced = _norm_sha(lock.get("synced_pr_head"))
+    evidence["recorded_synced_pr_head"] = recorded_synced
+    if recorded_synced is not None and old is not None and recorded_synced != old:
+        reasons.append(
+            f"durable lock already records synced head {recorded_synced}, not the "
+            f"expected old head {old}; a concurrent sync changed it (CAS fail closed)"
+        )
+
+    if reasons:
+        return {"allowed": False, "reasons": reasons, "evidence": evidence,
+                "expected_generation": lock_generation(lock)}
+
+    return {
+        "allowed": True,
+        "reasons": [
+            f"durable lock for issue #{issue_number} branch '{locked_branch}' is "
+            f"owned by the live session; refresh recorded head {old} -> {new}"
+        ],
+        "evidence": evidence,
+        "expected_generation": lock_generation(lock),
+    }
+
+
+def apply_durable_lock_head_refresh(
+    *,
+    remote: str,
+    org: str,
+    repo: str,
+    issue_number: int,
+    branch_name: str,
+    worktree_path: str,
+    pr_number: int | None,
+    identity: str | None,
+    profile: str | None,
+    current_pid: int | None,
+    expected_old_head: str | None,
+    new_head: str | None,
+    synced_at: str,
+    base_head: str | None = None,
+    provenance: str = LOCK_HEAD_REFRESH_PROVENANCE_MERGE_SYNC,
+    lock_dir: str | None = None,
+) -> dict[str, Any]:
+    """CAS-refresh the durable lock's recorded head after a branch sync (#871).
+
+    Reads the durable lock from disk, re-asserts ownership via
+    ``assess_durable_lock_head_refresh``, and — only when permitted — writes the
+    new synced head through ``bind_session_lock`` with a generation compare-and-
+    swap. Then re-reads the lock and proves it records the complete new head
+    (read-after-write). Any failure at any step returns ``refreshed=False`` with
+    reasons; the caller must treat that as a partial lifecycle failure and never
+    report a fully successful synchronization.
+    """
+    existing = load_issue_lock(
+        remote=remote, org=org, repo=repo, issue_number=issue_number, lock_dir=lock_dir
+    )
+    assessment = assess_durable_lock_head_refresh(
+        existing,
+        remote=remote,
+        org=org,
+        repo=repo,
+        issue_number=issue_number,
+        branch_name=branch_name,
+        worktree_path=worktree_path,
+        pr_number=pr_number,
+        identity=identity,
+        profile=profile,
+        current_pid=current_pid,
+        expected_old_head=expected_old_head,
+        new_head=new_head,
+        base_head=base_head,
+    )
+    result: dict[str, Any] = {
+        "refreshed": False,
+        "read_after_write_ok": False,
+        "prior_head": _norm_sha(expected_old_head),
+        "new_head": _norm_sha(new_head),
+        "reasons": list(assessment.get("reasons") or []),
+        "evidence": assessment.get("evidence"),
+    }
+    if not assessment.get("allowed"):
+        return result
+
+    new = _norm_sha(new_head)
+    old = _norm_sha(expected_old_head)
+    record = dict(existing or {})
+    sync_block = {
+        "last_synced_pr_head": new,
+        "prior_pr_head": old,
+        "base_head": _norm_sha(base_head),
+        "pr_number": pr_number,
+        "provenance": provenance,
+        "synced_at": synced_at,
+        "synced_by_pid": current_pid,
+        "synced_by": {
+            "username": str(identity or "").strip() or None,
+            "profile": str(profile or "").strip() or None,
+        },
+    }
+    record["synced_pr_head"] = new
+    record["branch_sync"] = sync_block
+    history = record.get("branch_sync_history")
+    if not isinstance(history, list):
+        history = []
+    history = list(history)
+    history.append(sync_block)
+    record["branch_sync_history"] = history
+
+    try:
+        bind_session_lock(
+            record,
+            lock_dir=lock_dir,
+            expected_generation=assessment.get("expected_generation"),
+            renewal_sanctioned=True,
+        )
+    except Exception as exc:  # CAS miss or write failure — partial lifecycle failure
+        result["reasons"].append(
+            f"durable lock head refresh write failed (fail closed): {exc}"
+        )
+        return result
+
+    after = load_issue_lock(
+        remote=remote, org=org, repo=repo, issue_number=issue_number, lock_dir=lock_dir
+    )
+    after_head = _norm_sha((after or {}).get("synced_pr_head"))
+    result["lock_generation_after"] = lock_generation(after)
+    if after_head == new and new is not None:
+        result["refreshed"] = True
+        result["read_after_write_ok"] = True
+        result["reasons"].append(
+            f"durable lock recorded head refreshed to {new} and verified by "
+            "read-after-write"
+        )
+    else:
+        result["reasons"].append(
+            "read-after-write verification failed: durable lock does not record "
+            f"the new head {new} (found {after_head}); partial lifecycle failure"
+        )
+    return result
@@ -145,6 +145,175 @@ def read_head_ancestry(
    return result


+def read_merge_sync_provenance(
+    worktree_path: str,
+    *,
+    prior_head_sha: str | None,
+    synced_head_sha: str | None,
+) -> dict:
+    """Observe whether ``synced_head_sha`` is a sanctioned merge-based branch sync
+    that advanced the PR branch past ``prior_head_sha`` (#871).
+
+    ``gitea_update_pr_branch_by_merge`` advances a PR branch by merging the base
+    branch *into* the branch (``POST /pulls/{n}/update?style=merge``). The result
+    is a merge commit ``M`` on the branch whose **first** parent is the prior
+    branch head and whose second parent is the base tip. When the owning session
+    then dies without the durable lock's recorded head being refreshed, the local
+    worktree still sits at ``prior_head_sha`` while the live PR head is ``M``.
+
+    Recovering that drift safely requires proving the remote head is *exactly*
+    such a merge-sync — not a rewrite, rebase, force-push, or an unrelated
+    commit. This is that server-side observation. It reports facts only; the
+    disposition lives in ``issue_lock_recovery``. Every field is read from git in
+    the declared worktree — nothing is supplied by, or reachable from, an MCP
+    caller (#871).
+
+    Provenance is proven only when ALL hold:
+
+    * both commits are present (a rewritten/force-moved prior head leaves the
+      object graph and fails closed);
+    * ``prior_head_sha`` is a strict ancestor of ``synced_head_sha`` (the branch
+      history is preserved, never replaced);
+    * ``synced_head_sha`` is a merge commit (two or more parents), i.e. a base
+      merged in — a plain fast-forward of new direct commits is not a sync;
+    * ``prior_head_sha`` is an ancestor of the merge's **first** parent, so the
+      branch mainline (first-parent lineage) still reaches the prior head — a
+      rebase/force-push that re-authored the branch side fails this.
+    """
+    path = (worktree_path or "").strip()
+    prior = (prior_head_sha or "").strip()
+    synced = (synced_head_sha or "").strip()
+    result: dict = {
+        "prior_head_sha": prior or None,
+        "synced_head_sha": synced or None,
+        "probe_ok": False,
+        "prior_present": False,
+        "synced_present": False,
+        "prior_is_ancestor": False,
+        "synced_is_merge": False,
+        "first_parent_reaches_prior": False,
+        "is_merge_sync": False,
+        "first_parent_sha": None,
+        "parent_count": None,
+        "proof": None,
+        "reasons": [],
+    }
+    if not path or not prior or not synced:
+        result["reasons"].append(
+            "merge-sync provenance probe requires a worktree path and both "
+            "commit SHAs"
+        )
+        return result
+    if prior == synced:
+        result["reasons"].append(
+            "prior and synced heads are identical; no branch sync occurred"
+        )
+        return result
+
+    def _present(sha: str) -> bool:
+        res = subprocess.run(
+            ["git", "-C", path, "rev-parse", "--verify", "--quiet", f"{sha}^{{commit}}"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return res.returncode == 0
+
+    def _is_ancestor(ancestor: str, descendant: str) -> bool | None:
+        res = subprocess.run(
+            ["git", "-C", path, "merge-base", "--is-ancestor", ancestor, descendant],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if res.returncode == 0:
+            return True
+        if res.returncode == 1:
+            return False
+        return None  # failed probe — never a silent "no"
+
+    try:
+        result["prior_present"] = _present(prior)
+        result["synced_present"] = _present(synced)
+    except OSError as exc:  # git unavailable — fail closed, never assume
+        result["reasons"].append(f"merge-sync provenance probe could not run: {exc}")
+        return result
+
+    if not result["prior_present"]:
+        result["reasons"].append(
+            f"prior head {prior} is not reachable in '{path}'; history may have "
+            "been rewritten or force-moved"
+        )
+    if not result["synced_present"]:
+        result["reasons"].append(
+            f"synced head {synced} is not reachable in '{path}'"
+        )
+    if not (result["prior_present"] and result["synced_present"]):
+        return result
+
+    ancestor = _is_ancestor(prior, synced)
+    if ancestor is None:
+        result["reasons"].append(
+            "ancestry probe failed; merge-sync provenance unproven"
+        )
+        return result
+    result["prior_is_ancestor"] = bool(ancestor)
+    if not ancestor:
+        result["reasons"].append(
+            f"prior head {prior} is not an ancestor of synced head {synced}; "
+            "the branch history was not preserved (not a merge-based sync)"
+        )
+        return result
+
+    parents_res = subprocess.run(
+        ["git", "-C", path, "rev-list", "--parents", "-n", "1", synced],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if parents_res.returncode != 0:
+        result["reasons"].append(
+            f"could not read parents of {synced}; merge-sync provenance unproven"
+        )
+        return result
+    tokens = (parents_res.stdout or "").split()
+    # tokens[0] is the commit itself; the rest are its parents.
+    parents = tokens[1:]
+    result["parent_count"] = len(parents)
+    result["synced_is_merge"] = len(parents) >= 2
+    if not result["synced_is_merge"]:
+        result["probe_ok"] = True
+        result["reasons"].append(
+            f"synced head {synced} has {len(parents)} parent(s); a merge-based "
+            "branch sync produces a merge commit (two or more parents)"
+        )
+        return result
+    first_parent = parents[0]
+    result["first_parent_sha"] = first_parent
+
+    fp_reaches = _is_ancestor(prior, first_parent) if prior != first_parent else True
+    if fp_reaches is None:
+        result["reasons"].append(
+            "first-parent ancestry probe failed; merge-sync provenance unproven"
+        )
+        return result
+    result["first_parent_reaches_prior"] = bool(fp_reaches)
+    result["probe_ok"] = True
+    if not fp_reaches:
+        result["reasons"].append(
+            f"merge first parent {first_parent} does not reach prior head "
+            f"{prior}; the branch mainline was re-authored (not a sanctioned sync)"
+        )
+        return result
+
+    result["is_merge_sync"] = True
+    result["proof"] = (
+        f"synced head {synced} is a merge commit (parents={len(parents)}) whose "
+        f"first-parent lineage reaches prior head {prior}; base merged into branch"
+    )
+    return result
+
+
 def read_recorded_base(
    worktree_path: str,
    *,
@@ -32,6 +32,17 @@ TASK_CAPABILITY_MAP: dict[str, dict[str, str]] = {
        "permission": "gitea.issue.comment",
        "role": "author",
    },
+    # #864: dirty-preserving same-claimant author-session rebind (dead owner PID).
+    # Author MCP tool path. Reconciler execute is gated inside the tool via
+    # authorize_reconciler_execute + role_kind checks (not this map entry).
+    "rebind_dirty_same_claimant_author_session": {
+        "permission": "gitea.issue.comment",
+        "role": "author",
+    },
+    "gitea_rebind_dirty_same_claimant_author_session": {
+        "permission": "gitea.issue.comment",
+        "role": "author",
+    },
    "set_issue_labels": {
        "permission": "gitea.issue.comment",
        "role": "author",
@@ -0,0 +1,551 @@
+"""Merged-PR awareness for the worktree cleanup audit (#858).
+
+Before #858 an ``issue_work`` worktree could never leave ``active_issue_work``:
+the audit had no PR linkage at all (``pr_number`` was structurally ``None``)
+and its only route to ``clean_stale_removable`` was a TTL derived from a
+``last_used_at`` that nothing ever populated. A merged, clean, unprotected
+worktree was therefore reported as active work forever, disagreeing with the
+PR-scoped reconciler.
+
+These tests use fabricated temporary repositories and synthetic PR records
+only. Nothing here removes a worktree or deletes a branch.
+"""
+
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(__import__("pathlib").Path(__file__).resolve().parent.parent))
+
+import merged_cleanup_reconcile as mcr  # noqa: E402
+import worktree_cleanup_audit as wca  # noqa: E402
+
+
+MERGED_BRANCH = "feat/issue-777-timeline"
+MERGED_PATH = "/repo/branches/issue-777-timeline"
+HEAD_SHA = "a" * 40
+
+
+def _pr(number, branch, *, merged=True, sha=HEAD_SHA, state=None):
+    """Synthetic Gitea PR payload."""
+    return {
+        "number": number,
+        "head": {"ref": branch, "sha": sha},
+        "merged_at": "2026-07-24T01:00:00Z" if merged else None,
+        "state": state or ("closed" if merged else "open"),
+    }
+
+
+def _porcelain(*entries):
+    out = []
+    for path, branch, sha in entries:
+        out.append(f"worktree {path}")
+        out.append(f"HEAD {sha}")
+        if branch is None:
+            out.append("detached")
+        else:
+            out.append(f"branch refs/heads/{branch}")
+        out.append("")
+    return "\n".join(out)
+
+
+class _AuditHarness(unittest.TestCase):
+    """Runs audit_branches_directory over a fabricated worktree listing."""
+
+    PORCELAIN = _porcelain(
+        ("/repo", "master", "f" * 40),
+        (MERGED_PATH, MERGED_BRANCH, HEAD_SHA),
+    )
+
+    def run_audit(self, *, dirty_paths=(), contained=True, **kwargs):
+        def fake_dirty(path):
+            if path in dirty_paths:
+                return {"exists": True, "dirty": True, "dirty_files": [" M x.py"]}
+            return {"exists": True, "dirty": False, "dirty_files": []}
+
+        with patch.object(
+            wca, "list_worktrees",
+            return_value=wca.parse_worktree_porcelain(self.PORCELAIN),
+        ), patch.object(
+            wca, "read_worktree_dirty", side_effect=fake_dirty
+        ), patch.object(
+            wca, "git_worktree_list", return_value="(mocked)"
+        ), patch.object(
+            wca, "is_head_ancestor_of_ref", return_value=contained
+        ):
+            report = wca.audit_branches_directory("/repo", **kwargs)
+        return {wt["path"]: wt for wt in report["worktrees"]}, report
+
+    def merged_audit(self, **kwargs):
+        kwargs.setdefault("pr_index", wca.build_pr_index([_pr(849, MERGED_BRANCH)]))
+        kwargs.setdefault("master_ref", "prgs/master")
+        return self.run_audit(**kwargs)
+
+
+class TestMergedWorktreeBecomesRemovable(_AuditHarness):
+    def test_clean_merged_issue_worktree_is_linked_and_removable(self):
+        by_path, report = self.merged_audit()
+        entry = by_path[MERGED_PATH]
+
+        self.assertEqual(entry["classification"], wca.CLASS_CLEAN_STALE_REMOVABLE)
+        self.assertTrue(entry["removable"])
+        self.assertEqual(entry["merged_pr_linkage"]["status"], wca.LINKAGE_MERGED)
+        self.assertEqual(entry["merged_pr_cleanup"]["block_reasons"], [])
+        self.assertIn(MERGED_PATH, [c["path"] for c in report["removable_candidates"]])
+
+    def test_pr_number_populated_from_authoritative_linkage(self):
+        by_path, _ = self.merged_audit()
+        self.assertEqual(by_path[MERGED_PATH]["pr_number"], 849)
+
+    def test_regression_without_pr_evidence_stays_active_issue_work(self):
+        """The pre-#858 behaviour, still correct when no PR state is supplied."""
+        by_path, _ = self.run_audit()
+        entry = by_path[MERGED_PATH]
+        self.assertEqual(entry["classification"], wca.CLASS_ACTIVE_ISSUE_WORK)
+        self.assertFalse(entry["removable"])
+        self.assertIsNone(entry["pr_number"])
+
+
+class TestProtectiveSignalsSurvive(_AuditHarness):
+    def test_open_pr_worktree_is_not_removable(self):
+        index = wca.build_pr_index([_pr(900, MERGED_BRANCH, merged=False)])
+        by_path, _ = self.run_audit(
+            pr_index=index,
+            master_ref="prgs/master",
+            open_pr_branches={MERGED_BRANCH},
+        )
+        entry = by_path[MERGED_PATH]
+        self.assertEqual(entry["classification"], wca.CLASS_ACTIVE_OPEN_PR)
+        self.assertFalse(entry["removable"])
+        # linkage still reports the owning PR, it just is not merge proof
+        self.assertEqual(entry["merged_pr_linkage"]["status"], wca.LINKAGE_OPEN)
+        self.assertEqual(entry["pr_number"], 900)
+
+    def test_dirty_tracked_worktree_is_not_removable(self):
+        by_path, _ = self.merged_audit(dirty_paths=(MERGED_PATH,))
+        entry = by_path[MERGED_PATH]
+        self.assertEqual(entry["classification"], wca.CLASS_DIRTY_LOCAL)
+        self.assertFalse(entry["removable"])
+        self.assertIn(
+            "worktree has uncommitted changes",
+            entry["merged_pr_cleanup"]["block_reasons"],
+        )
+
+    def test_untracked_only_worktree_is_not_removable(self):
+        """``git status --porcelain`` reports untracked files as dirty too."""
+        def untracked(path):
+            if path == MERGED_PATH:
+                return {"exists": True, "dirty": True, "dirty_files": ["?? scratch.txt"]}
+            return {"exists": True, "dirty": False, "dirty_files": []}
+
+        with patch.object(
+            wca, "list_worktrees",
+            return_value=wca.parse_worktree_porcelain(self.PORCELAIN),
+        ), patch.object(
+            wca, "read_worktree_dirty", side_effect=untracked
+        ), patch.object(
+            wca, "git_worktree_list", return_value="(mocked)"
+        ), patch.object(
+            wca, "is_head_ancestor_of_ref", return_value=True
+        ):
+            report = wca.audit_branches_directory(
+                "/repo",
+                pr_index=wca.build_pr_index([_pr(849, MERGED_BRANCH)]),
+                master_ref="prgs/master",
+            )
+        entry = {wt["path"]: wt for wt in report["worktrees"]}[MERGED_PATH]
+        self.assertEqual(entry["classification"], wca.CLASS_DIRTY_LOCAL)
+        self.assertFalse(entry["removable"])
+
+    def test_active_lease_by_issue_number_is_protective(self):
+        by_path, _ = self.merged_audit(leased_issue_numbers={777})
+        entry = by_path[MERGED_PATH]
+        self.assertTrue(entry["has_active_lease"])
+        self.assertEqual(entry["classification"], wca.CLASS_ACTIVE_ISSUE_WORK)
+        self.assertFalse(entry["removable"])
+
+    def test_active_lease_by_branch_is_protective(self):
+        by_path, _ = self.merged_audit(leased_branches={MERGED_BRANCH})
+        entry = by_path[MERGED_PATH]
+        self.assertTrue(entry["has_active_lease"])
+        self.assertFalse(entry["removable"])
+
+    def test_active_issue_lock_is_protective(self):
+        by_path, _ = self.merged_audit(active_issue_branches={MERGED_BRANCH})
+        entry = by_path[MERGED_PATH]
+        self.assertTrue(entry["has_active_issue_lock"])
+        self.assertEqual(entry["classification"], wca.CLASS_ACTIVE_ISSUE_WORK)
+        self.assertFalse(entry["removable"])
+
+    def test_live_session_worktree_is_protective(self):
+        by_path, _ = self.merged_audit(live_session_paths={MERGED_PATH})
+        entry = by_path[MERGED_PATH]
+        self.assertTrue(entry["has_live_session"])
+        self.assertEqual(entry["classification"], wca.CLASS_ACTIVE_ISSUE_WORK)
+        self.assertFalse(entry["removable"])
+
+    def test_head_not_contained_in_master_is_not_removable(self):
+        by_path, _ = self.merged_audit(contained=False)
+        entry = by_path[MERGED_PATH]
+        self.assertEqual(entry["classification"], wca.CLASS_ACTIVE_ISSUE_WORK)
+        self.assertFalse(entry["removable"])
+        self.assertIn(
+            "worktree head is not contained in authoritative master "
+            "(unmerged commits remain)",
+            entry["merged_pr_cleanup"]["block_reasons"],
+        )
+
+    def test_unknown_containment_fails_closed(self):
+        by_path, _ = self.merged_audit(contained=None)
+        entry = by_path[MERGED_PATH]
+        self.assertFalse(entry["removable"])
+        self.assertIn(
+            "containment of the worktree head in master is unknown",
+            entry["merged_pr_cleanup"]["block_reasons"],
+        )
+
+    def test_missing_master_ref_fails_closed(self):
+        by_path, _ = self.run_audit(
+            pr_index=wca.build_pr_index([_pr(849, MERGED_BRANCH)])
+        )
+        self.assertFalse(by_path[MERGED_PATH]["removable"])
+
+    def test_unmerged_owning_pr_is_not_removable(self):
+        index = wca.build_pr_index([_pr(901, MERGED_BRANCH, merged=False)])
+        by_path, _ = self.run_audit(pr_index=index, master_ref="prgs/master")
+        entry = by_path[MERGED_PATH]
+        self.assertFalse(entry["removable"])
+        self.assertIn(
+            "owning PR #901 is not merged",
+            entry["merged_pr_cleanup"]["block_reasons"],
+        )
+
+    def test_control_checkout_is_never_removable(self):
+        by_path, _ = self.merged_audit()
+        control = by_path["/repo"]
+        self.assertTrue(control["is_protected"])
+        self.assertEqual(control["classification"], wca.CLASS_UNSAFE_UNKNOWN)
+        self.assertFalse(control["removable"])
+
+    def test_control_checkout_not_removable_even_if_linked_and_merged(self):
+        """A merged PR on the control checkout must not unlock removal."""
+        porcelain = _porcelain(("/repo", MERGED_BRANCH, HEAD_SHA))
+        with patch.object(
+            wca, "list_worktrees", return_value=wca.parse_worktree_porcelain(porcelain)
+        ), patch.object(
+            wca, "read_worktree_dirty",
+            return_value={"exists": True, "dirty": False, "dirty_files": []},
+        ), patch.object(
+            wca, "git_worktree_list", return_value="(mocked)"
+        ), patch.object(
+            wca, "is_head_ancestor_of_ref", return_value=True
+        ):
+            report = wca.audit_branches_directory(
+                "/repo",
+                pr_index=wca.build_pr_index([_pr(849, MERGED_BRANCH)]),
+                master_ref="prgs/master",
+            )
+        entry = report["worktrees"][0]
+        self.assertEqual(entry["classification"], wca.CLASS_UNSAFE_UNKNOWN)
+        self.assertFalse(entry["removable"])
+
+
+class TestAmbiguousLinkageFailsClosed(_AuditHarness):
+    def test_competing_prs_on_one_branch_fail_closed(self):
+        index = wca.build_pr_index(
+            [_pr(849, MERGED_BRANCH), _pr(860, MERGED_BRANCH)]
+        )
+        by_path, _ = self.run_audit(pr_index=index, master_ref="prgs/master")
+        entry = by_path[MERGED_PATH]
+        self.assertEqual(entry["merged_pr_linkage"]["status"], wca.LINKAGE_AMBIGUOUS)
+        self.assertIsNone(entry["pr_number"])
+        self.assertEqual(entry["classification"], wca.CLASS_ACTIVE_ISSUE_WORK)
+        self.assertFalse(entry["removable"])
+
+    def test_merged_plus_open_pr_on_one_branch_fails_closed(self):
+        index = wca.build_pr_index(
+            [_pr(849, MERGED_BRANCH), _pr(861, MERGED_BRANCH, merged=False)]
+        )
+        by_path, _ = self.run_audit(pr_index=index, master_ref="prgs/master")
+        entry = by_path[MERGED_PATH]
+        self.assertEqual(entry["merged_pr_linkage"]["status"], wca.LINKAGE_AMBIGUOUS)
+        self.assertFalse(entry["removable"])
+
+    def test_no_owning_pr_fails_closed(self):
+        by_path, _ = self.run_audit(
+            pr_index=wca.build_pr_index([_pr(849, "feat/other-branch")]),
+            master_ref="prgs/master",
+        )
+        entry = by_path[MERGED_PATH]
+        self.assertEqual(entry["merged_pr_linkage"]["status"], wca.LINKAGE_NONE)
+        self.assertFalse(entry["removable"])
+
+    def test_malformed_pr_records_are_dropped_not_guessed(self):
+        index = wca.build_pr_index(
+            [
+                {"number": None, "head": {"ref": MERGED_BRANCH}},
+                {"number": 5, "head": {}},
+                {"number": "not-an-int", "head": {"ref": MERGED_BRANCH}},
+            ]
+        )
+        self.assertEqual(index, {})
+        self.assertEqual(
+            wca.resolve_owning_pr(branch=MERGED_BRANCH, pr_index=index)["status"],
+            wca.LINKAGE_NONE,
+        )
+
+    def test_detached_worktree_has_no_branch_linkage(self):
+        self.assertEqual(
+            wca.resolve_owning_pr(branch=None, pr_index={})["status"],
+            wca.LINKAGE_UNKNOWN,
+        )
+
+
+class TestUnrelatedClassificationsUnchanged(unittest.TestCase):
+    """Non-issue_work worktrees keep their pre-#858 classifications."""
+
+    PORCELAIN = _porcelain(
+        ("/repo", "master", "f" * 40),
+        ("/repo/branches/review-pr42", "review-pr42", "2" * 40),
+        ("/repo/branches/baseline-master-x", "baseline-master-x", "3" * 40),
+        ("/repo/branches/conflict-fix-pr50", "conflict-fix-pr50", "4" * 40),
+        ("/repo/branches/review-pr99", None, "5" * 40),
+    )
+
+    def _audit(self, **kwargs):
+        with patch.object(
+            wca, "list_worktrees",
+            return_value=wca.parse_worktree_porcelain(self.PORCELAIN),
+        ), patch.object(
+            wca, "read_worktree_dirty",
+            return_value={"exists": True, "dirty": False, "dirty_files": []},
+        ), patch.object(
+            wca, "git_worktree_list", return_value="(mocked)"
+        ), patch.object(
+            wca, "is_head_ancestor_of_ref", return_value=True
+        ):
+            report = wca.audit_branches_directory("/repo", **kwargs)
+        return {wt["path"]: wt for wt in report["worktrees"]}
+
+    def test_classifications_identical_with_and_without_pr_evidence(self):
+        without = self._audit()
+        with_evidence = self._audit(
+            pr_index=wca.build_pr_index([_pr(849, MERGED_BRANCH)]),
+            master_ref="prgs/master",
+        )
+        self.assertEqual(
+            {p: e["classification"] for p, e in without.items()},
+            {p: e["classification"] for p, e in with_evidence.items()},
+        )
+
+    def test_lease_on_issue_does_not_capture_similarly_named_scratch_trees(self):
+        """A lease on issue 777 protects issue work, not baseline/review trees."""
+        porcelain = _porcelain(
+            ("/repo/branches/baseline-master-issue-777", "baseline-issue-777", "7" * 40),
+            ("/repo/branches/issue-777-timeline", MERGED_BRANCH, HEAD_SHA),
+        )
+        with patch.object(
+            wca, "list_worktrees", return_value=wca.parse_worktree_porcelain(porcelain)
+        ), patch.object(
+            wca, "read_worktree_dirty",
+            return_value={"exists": True, "dirty": False, "dirty_files": []},
+        ), patch.object(
+            wca, "git_worktree_list", return_value="(mocked)"
+        ), patch.object(
+            wca, "is_head_ancestor_of_ref", return_value=True
+        ):
+            report = wca.audit_branches_directory(
+                "/repo",
+                pr_index=wca.build_pr_index([_pr(849, MERGED_BRANCH)]),
+                master_ref="prgs/master",
+                leased_issue_numbers={777},
+            )
+        by_path = {wt["path"]: wt for wt in report["worktrees"]}
+
+        baseline = by_path["/repo/branches/baseline-master-issue-777"]
+        self.assertFalse(baseline["has_active_lease"])
+        self.assertEqual(baseline["classification"], wca.CLASS_CLEAN_STALE_REMOVABLE)
+
+        issue_work = by_path["/repo/branches/issue-777-timeline"]
+        self.assertTrue(issue_work["has_active_lease"])
+        self.assertFalse(issue_work["removable"])
+
+    def test_review_and_baseline_still_removable(self):
+        by_path = self._audit(
+            pr_index=wca.build_pr_index([]), master_ref="prgs/master"
+        )
+        self.assertEqual(
+            by_path["/repo/branches/review-pr42"]["classification"],
+            wca.CLASS_CLEAN_STALE_REMOVABLE,
+        )
+        self.assertEqual(
+            by_path["/repo/branches/baseline-master-x"]["classification"],
+            wca.CLASS_CLEAN_STALE_REMOVABLE,
+        )
+        self.assertEqual(
+            by_path["/repo/branches/review-pr99"]["classification"],
+            wca.CLASS_DETACHED_REVIEW_LEFTOVER,
+        )
+
+    def test_conflict_fix_ttl_behaviour_unchanged(self):
+        """conflict_fix still needs only TTL expiry; #858 did not touch it."""
+        self.assertEqual(
+            wca.classify_worktree(
+                workflow_type=wca.WORKFLOW_CONFLICT_FIX,
+                is_dirty=False,
+                ttl_expired=True,
+            ),
+            wca.CLASS_CLEAN_STALE_REMOVABLE,
+        )
+        self.assertEqual(
+            wca.classify_worktree(
+                workflow_type=wca.WORKFLOW_CONFLICT_FIX,
+                is_dirty=False,
+                ttl_expired=False,
+            ),
+            wca.CLASS_ACTIVE_ISSUE_WORK,
+        )
+
+    def test_issue_work_ttl_alone_no_longer_grants_removal(self):
+        """Age is not landing proof: TTL alone must not reclaim issue work."""
+        self.assertEqual(
+            wca.classify_worktree(
+                workflow_type=wca.WORKFLOW_ISSUE_WORK,
+                is_dirty=False,
+                ttl_expired=True,
+            ),
+            wca.CLASS_ACTIVE_ISSUE_WORK,
+        )
+
+
+class TestAssessorPerformsNoDeletion(_AuditHarness):
+    def test_audit_never_removes_a_worktree(self):
+        with patch.object(wca, "remove_worktree") as removal:
+            self.merged_audit()
+        removal.assert_not_called()
+
+    def test_audit_shells_out_to_no_destructive_git_command(self):
+        seen = []
+        real_run = subprocess.run
+
+        def recording_run(cmd, *args, **kwargs):
+            seen.append(cmd)
+            return real_run(["true"], *args, **kwargs)
+
+        with patch.object(subprocess, "run", side_effect=recording_run):
+            wca.audit_branches_directory("/nonexistent-repo-for-audit")
+
+        joined = [" ".join(c) if isinstance(c, list) else str(c) for c in seen]
+        for cmd in joined:
+            self.assertNotIn("worktree remove", cmd)
+            self.assertNotIn("branch -D", cmd)
+            self.assertNotIn("push", cmd)
+
+
+class TestAgreementWithPrScopedReconciler(unittest.TestCase):
+    """The audit and merged_cleanup_reconcile must agree on identical input.
+
+    Uses a real throwaway git repository so containment is computed by git
+    rather than asserted. Nothing outside the temporary directory is touched.
+    """
+
+    def _git(self, *args):
+        subprocess.run(
+            ["git", "-C", self.root, *args],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = os.path.realpath(self._tmp.name)
+        self._git("init", "-b", "master", ".")
+        self._git("config", "user.email", "[email protected]")
+        self._git("config", "user.name", "Test")
+        with open(os.path.join(self.root, "seed.txt"), "w") as fh:
+            fh.write("seed\n")
+        self._git("add", "seed.txt")
+        self._git("commit", "-m", "seed")
+
+        self.branch = "feat/issue-777-timeline"
+        self._git("checkout", "-b", self.branch)
+        with open(os.path.join(self.root, "feature.txt"), "w") as fh:
+            fh.write("feature\n")
+        self._git("add", "feature.txt")
+        self._git("commit", "-m", "feature")
+        self.head_sha = subprocess.run(
+            ["git", "-C", self.root, "rev-parse", "HEAD"],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip()
+        self._git("checkout", "master")
+        self._git("merge", "--no-ff", "-m", "merge feature", self.branch)
+
+        self.worktree = os.path.join(self.root, "branches", "issue-777-timeline")
+        self._git("worktree", "add", self.worktree, self.branch)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def _pr_index(self):
+        return wca.build_pr_index(
+            [
+                {
+                    "number": 849,
+                    "head": {"ref": self.branch, "sha": self.head_sha},
+                    "merged_at": "2026-07-24T01:00:00Z",
+                }
+            ]
+        )
+
+    def _audit_entry(self):
+        report = wca.audit_branches_directory(
+            self.root, pr_index=self._pr_index(), master_ref="master"
+        )
+        return next(wt for wt in report["worktrees"] if wt["path"] == self.worktree)
+
+    def _reconciler_entry(self):
+        return mcr.assess_local_worktree_cleanup(
+            pr_number=849,
+            head_branch=self.branch,
+            merged=True,
+            worktree_state=mcr.resolve_cleanup_worktree_state(
+                project_root=self.root,
+                head_branch=self.branch,
+                issue_number=777,
+                pr_head_sha=self.head_sha,
+                target_ref="master",
+            ),
+            active_lock=False,
+        )
+
+    def test_both_assessors_agree_the_worktree_is_safe(self):
+        audit_entry = self._audit_entry()
+        reconciler = self._reconciler_entry()
+
+        self.assertTrue(reconciler["safe_to_remove_worktree"], reconciler)
+        self.assertTrue(audit_entry["removable"], audit_entry)
+        self.assertEqual(audit_entry["pr_number"], reconciler["pr_number"])
+        self.assertEqual(audit_entry["merged_pr_cleanup"]["block_reasons"], [])
+        self.assertEqual(reconciler["block_reasons"], [])
+
+    def test_both_assessors_agree_a_dirty_worktree_is_unsafe(self):
+        with open(os.path.join(self.worktree, "feature.txt"), "a") as fh:
+            fh.write("local edit\n")
+
+        audit_entry = self._audit_entry()
+        reconciler = self._reconciler_entry()
+
+        self.assertFalse(audit_entry["removable"])
+        self.assertFalse(reconciler["safe_to_remove_worktree"])
+
+    def test_worktree_still_present_after_audit(self):
+        self._audit_entry()
+        self.assertTrue(os.path.isdir(self.worktree))
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,630 @@
+"""Durable linked-issue lock head refresh + merge-sync dead-session recovery (#871).
+
+``gitea_update_pr_branch_by_merge`` advances a PR's *remote* head but historically
+never advanced the linked durable issue lock's recorded head. After the owning
+session died the drifted lock became unrecoverable and no further synchronization
+was possible (PR #866 / issue #855).
+
+Two halves are covered:
+
+* the write-side refresh (``issue_lock_store.assess/apply_durable_lock_head_refresh``)
+  that records the new synced head under compare-and-swap with read-after-write; and
+* the read-side recovery relation (``issue_lock_recovery`` +
+  ``issue_lock_worktree.read_merge_sync_provenance``) that lets a dead-session lock
+  whose recorded head is a merge-sync *ancestor* of the live PR head be recovered —
+  and nothing else.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import issue_lock_recovery  # noqa: E402
+import issue_lock_store  # noqa: E402
+import issue_lock_worktree  # noqa: E402
+
+ISSUE = 8710
+PR_NUMBER = 8711
+BRANCH = f"fix/issue-{ISSUE}-durable-lock-head-refresh"
+IDENTITY = "example-user"
+PROFILE = "example-author"
+OLD = "a" * 40
+NEW1 = "b" * 40
+NEW2 = "c" * 40
+BASE = "d" * 40
+REMOTE = "prgs"
+ORG = "ExampleOrg"
+REPO = "ExampleRepo"
+
+
+def dead_pid() -> int:
+    proc = subprocess.Popen([sys.executable, "-c", "pass"])
+    proc.wait()
+    return proc.pid
+
+
+def future_ts(hours: int = 4) -> str:
+    return (
+        (datetime.now(timezone.utc) + timedelta(hours=hours))
+        .isoformat()
+        .replace("+00:00", "Z")
+    )
+
+
+def _git(cwd, *args):
+    return subprocess.run(
+        ["git", "-C", cwd, *args],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+
+def _rev(cwd, ref="HEAD") -> str:
+    return _git(cwd, "rev-parse", ref).stdout.strip()
+
+
+def build_merge_sync_repo(tmp: str) -> dict:
+    """Build a repo where a feature branch was synced by merging master in.
+
+    Returns a dict with the prior (branch) head, the synced merge-commit head,
+    the master tip, plus a rebase-style linear descendant and an unrelated head.
+    """
+    _git(tmp, "init", "-q", "-b", "master")
+    _git(tmp, "config", "user.email", "[email protected]")
+    _git(tmp, "config", "user.name", "T")
+    Path(tmp, "base.txt").write_text("base\n")
+    _git(tmp, "add", "-A")
+    _git(tmp, "commit", "-q", "-m", "root")
+
+    # Feature branch cut from root, one commit — this is the PRIOR/recorded head.
+    _git(tmp, "checkout", "-q", "-b", BRANCH)
+    Path(tmp, "feature.txt").write_text("feature\n")
+    _git(tmp, "add", "-A")
+    _git(tmp, "commit", "-q", "-m", "feature work")
+    prior = _rev(tmp)
+
+    # Master advances (the base the sync will merge in).
+    _git(tmp, "checkout", "-q", "master")
+    Path(tmp, "base.txt").write_text("base\nmore\n")
+    _git(tmp, "add", "-A")
+    _git(tmp, "commit", "-q", "-m", "master advance")
+    master_tip = _rev(tmp)
+
+    # Sync: merge master INTO the feature branch → merge commit, first parent = prior.
+    _git(tmp, "checkout", "-q", BRANCH)
+    _git(tmp, "merge", "-q", "--no-ff", "-m", "Merge master into feature", "master")
+    synced = _rev(tmp)
+
+    # A plain linear descendant of prior (NOT a merge) — a rebase/extra-commit shape.
+    _git(tmp, "checkout", "-q", "-b", "linear-branch", prior)
+    Path(tmp, "extra.txt").write_text("extra\n")
+    _git(tmp, "add", "-A")
+    _git(tmp, "commit", "-q", "-m", "extra linear commit")
+    linear = _rev(tmp)
+
+    # An unrelated root (force-push / rewritten history shape).
+    unrelated_dir = tempfile.mkdtemp()
+    _git(unrelated_dir, "init", "-q", "-b", "x")
+    _git(unrelated_dir, "config", "user.email", "[email protected]")
+    _git(unrelated_dir, "config", "user.name", "T")
+    Path(unrelated_dir, "z.txt").write_text("z\n")
+    _git(unrelated_dir, "add", "-A")
+    _git(unrelated_dir, "commit", "-q", "-m", "unrelated")
+    unrelated = _rev(unrelated_dir)
+
+    # Leave the worktree checked out on the feature branch at the PRIOR head, as
+    # a dead author session that never advanced would have left it.
+    _git(tmp, "checkout", "-q", BRANCH)
+    _git(tmp, "reset", "-q", "--hard", prior)
+
+    return {
+        "prior": prior,
+        "master_tip": master_tip,
+        "synced": synced,
+        "linear": linear,
+        "unrelated": unrelated,
+    }
+
+
+# ─────────────────────────── write-side refresh ───────────────────────────
+
+
+class TestDurableLockHeadRefresh(unittest.TestCase):
+    def setUp(self):
+        self.lock_dir = tempfile.mkdtemp()
+        self.wt = tempfile.mkdtemp()
+        lock_data = {
+            "issue_number": ISSUE,
+            "branch_name": BRANCH,
+            "worktree_path": self.wt,
+            "remote": REMOTE,
+            "org": ORG,
+            "repo": REPO,
+            "claimant": {"username": IDENTITY, "profile": PROFILE},
+            "work_lease": {
+                "operation_type": issue_lock_store.AUTHOR_ISSUE_WORK_LEASE,
+                "issue_number": ISSUE,
+                "branch": BRANCH,
+                "worktree_path": self.wt,
+                "claimant": {"username": IDENTITY, "profile": PROFILE},
+                "expires_at": future_ts(),
+            },
+        }
+        issue_lock_store.bind_session_lock(lock_data, lock_dir=self.lock_dir)
+
+    def _apply(self, **over):
+        kw = dict(
+            remote=REMOTE, org=ORG, repo=REPO, issue_number=ISSUE,
+            branch_name=BRANCH, worktree_path=self.wt, pr_number=PR_NUMBER,
+            identity=IDENTITY, profile=PROFILE, current_pid=os.getpid(),
+            expected_old_head=OLD, new_head=NEW1, synced_at=future_ts(0),
+            base_head=BASE, lock_dir=self.lock_dir,
+        )
+        kw.update(over)
+        return issue_lock_store.apply_durable_lock_head_refresh(**kw)
+
+    def _load(self):
+        return issue_lock_store.load_issue_lock(
+            remote=REMOTE, org=ORG, repo=REPO, issue_number=ISSUE,
+            lock_dir=self.lock_dir,
+        )
+
+    def test_first_sync_updates_recorded_head(self):
+        """AC1: first base sync writes the resulting head to the durable lock."""
+        res = self._apply()
+        self.assertTrue(res["refreshed"], res["reasons"])
+        self.assertTrue(res["read_after_write_ok"])
+        self.assertEqual(self._load().get("synced_pr_head"), NEW1)
+
+    def test_second_sync_after_master_advance(self):
+        """AC2: a later master advance permits a second sanctioned sync."""
+        self.assertTrue(self._apply()["refreshed"])
+        res2 = self._apply(expected_old_head=NEW1, new_head=NEW2)
+        self.assertTrue(res2["refreshed"], res2["reasons"])
+        self.assertEqual(self._load().get("synced_pr_head"), NEW2)
+        history = self._load().get("branch_sync_history")
+        self.assertEqual(len(history), 2)
+        self.assertEqual(history[0]["last_synced_pr_head"], NEW1)
+        self.assertEqual(history[1]["prior_pr_head"], NEW1)
+
+    def test_cas_detects_concurrent_head_change(self):
+        """AC6: CAS refuses when the recorded synced head is not the old head."""
+        self.assertTrue(self._apply()["refreshed"])  # recorded head now NEW1
+        # A second sync claiming the old head is still OLD must fail closed.
+        res = self._apply(expected_old_head=OLD, new_head=NEW2)
+        self.assertFalse(res["refreshed"])
+        self.assertTrue(any("CAS" in r or "concurrent" in r for r in res["reasons"]))
+        self.assertEqual(self._load().get("synced_pr_head"), NEW1)
+
+    def test_wrong_issue_fails_closed(self):
+        res = self._apply(issue_number=999999)
+        self.assertFalse(res["refreshed"])
+
+    def test_wrong_branch_fails_closed(self):
+        res = self._apply(branch_name="fix/issue-8710-wrong")
+        self.assertFalse(res["refreshed"])
+
+    def test_wrong_repo_fails_closed(self):
+        res = self._apply(repo="OtherRepo")
+        self.assertFalse(res["refreshed"])
+
+    def test_wrong_identity_fails_closed(self):
+        res = self._apply(identity="intruder")
+        self.assertFalse(res["refreshed"])
+
+    def test_wrong_profile_fails_closed(self):
+        res = self._apply(profile="prgs-reviewer")
+        self.assertFalse(res["refreshed"])
+
+    def test_foreign_session_fails_closed(self):
+        """A refresh is not a recovery: the current process must own the lock."""
+        path = issue_lock_store.lock_file_path(
+            remote=REMOTE, org=ORG, repo=REPO, issue_number=ISSUE,
+            lock_dir=self.lock_dir,
+        )
+        rec = issue_lock_store.read_lock_file(path)
+        rec["session_pid"] = dead_pid()
+        rec["pid"] = rec["session_pid"]
+        issue_lock_store.save_lock_file(path, rec)
+        res = self._apply()
+        self.assertFalse(res["refreshed"])
+        self.assertTrue(any("current session" in r or "live owner" in r for r in res["reasons"]))
+
+    def test_new_equals_old_fails_closed(self):
+        res = self._apply(expected_old_head=OLD, new_head=OLD)
+        self.assertFalse(res["refreshed"])
+
+    def test_non_full_sha_fails_closed(self):
+        self.assertFalse(self._apply(new_head="deadbeef")["refreshed"])
+        self.assertFalse(self._apply(expected_old_head="xyz")["refreshed"])
+
+    def test_no_lock_fails_closed(self):
+        assessment = issue_lock_store.assess_durable_lock_head_refresh(
+            None, remote=REMOTE, org=ORG, repo=REPO, issue_number=ISSUE,
+            branch_name=BRANCH, worktree_path=self.wt, pr_number=PR_NUMBER,
+            identity=IDENTITY, profile=PROFILE, current_pid=os.getpid(),
+            expected_old_head=OLD, new_head=NEW1,
+        )
+        self.assertFalse(assessment["allowed"])
+
+
+# ─────────────────────── merge-sync provenance (real git) ───────────────────
+
+
+class TestMergeSyncProvenanceObservation(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp()
+        self.shas = build_merge_sync_repo(self.tmp)
+
+    def test_merge_sync_is_recognized(self):
+        obs = issue_lock_worktree.read_merge_sync_provenance(
+            self.tmp, prior_head_sha=self.shas["prior"],
+            synced_head_sha=self.shas["synced"],
+        )
+        self.assertTrue(obs["is_merge_sync"], obs["reasons"])
+        self.assertTrue(obs["prior_is_ancestor"])
+        self.assertTrue(obs["synced_is_merge"])
+        self.assertTrue(obs["first_parent_reaches_prior"])
+
+    def test_linear_descendant_is_not_a_merge_sync(self):
+        """A plain non-merge descendant (rebase/extra commit) is not a sync."""
+        obs = issue_lock_worktree.read_merge_sync_provenance(
+            self.tmp, prior_head_sha=self.shas["prior"],
+            synced_head_sha=self.shas["linear"],
+        )
+        self.assertTrue(obs["probe_ok"])
+        self.assertFalse(obs["is_merge_sync"])
+        self.assertFalse(obs["synced_is_merge"])
+
+    def test_unrelated_history_fails_closed(self):
+        """A rewritten/force-pushed head where prior is unreachable fails closed."""
+        obs = issue_lock_worktree.read_merge_sync_provenance(
+            self.tmp, prior_head_sha=self.shas["prior"],
+            synced_head_sha=self.shas["unrelated"],
+        )
+        self.assertFalse(obs["is_merge_sync"])
+
+    def test_missing_args_fail_closed(self):
+        obs = issue_lock_worktree.read_merge_sync_provenance(
+            self.tmp, prior_head_sha=None, synced_head_sha=self.shas["synced"],
+        )
+        self.assertFalse(obs["is_merge_sync"])
+
+
+# ──────────────────── merge-sync dead-session recovery ──────────────────────
+
+
+def make_dead_lock(worktree, **over):
+    pid = dead_pid()
+    lock = {
+        "issue_number": ISSUE,
+        "branch_name": BRANCH,
+        "worktree_path": worktree,
+        "remote": REMOTE,
+        "org": ORG,
+        "repo": REPO,
+        "session_pid": pid,
+        "pid": pid,
+        "claimant": {"username": IDENTITY, "profile": PROFILE},
+        "work_lease": {
+            "operation_type": issue_lock_store.AUTHOR_ISSUE_WORK_LEASE,
+            "issue_number": ISSUE,
+            "branch": BRANCH,
+            "worktree_path": worktree,
+            "claimant": {"username": IDENTITY, "profile": PROFILE},
+            "expires_at": future_ts(),
+        },
+    }
+    lock.update(over)
+    return lock
+
+
+def sync_prov(prior, synced, **over):
+    d = {
+        "prior_head_sha": prior,
+        "synced_head_sha": synced,
+        "probe_ok": True,
+        "prior_present": True,
+        "synced_present": True,
+        "prior_is_ancestor": True,
+        "synced_is_merge": True,
+        "first_parent_reaches_prior": True,
+        "is_merge_sync": True,
+        "first_parent_sha": prior,
+        "parent_count": 2,
+        "proof": f"{synced} merged base into branch above {prior}",
+        "reasons": [],
+    }
+    d.update(over)
+    return d
+
+
+class TestMergeSyncRecovery(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp()
+        self.shas = build_merge_sync_repo(self.tmp)
+        self.prior = self.shas["prior"]
+        self.synced = self.shas["synced"]
+
+    def _assess(self, **over):
+        lock = over.pop("_lock", None) or make_dead_lock(self.tmp)
+        kw = dict(
+            issue_number=ISSUE, branch_name=BRANCH, worktree_path=self.tmp,
+            remote=REMOTE, org=ORG, repo=REPO, identity=IDENTITY, profile=PROFILE,
+            current_branch=BRANCH, porcelain_status="",
+            head_sha=self.prior, remote_head_sha=self.synced,
+            pr_head_sha=self.synced, pr_number=PR_NUMBER,
+            competing_live_locks=[], candidate_branches=[BRANCH],
+            current_pid=os.getpid(),
+            remote_branch_exists=True,
+            sync_provenance=sync_prov(self.prior, self.synced),
+        )
+        kw.update(over)
+        return issue_lock_recovery.assess_dead_session_lock_recovery(lock, **kw)
+
+    def test_merge_sync_drift_is_recoverable(self):
+        """AC3/AC4: dead session, recorded head is a merge-sync ancestor of PR head."""
+        res = self._assess()
+        self.assertEqual(res["outcome"], issue_lock_recovery.RECOVERY_SANCTIONED, res["reasons"])
+        self.assertEqual(
+            res["evidence"]["head_relation"],
+            issue_lock_recovery.HEAD_RELATION_REMOTE_MERGE_SYNCED,
+        )
+        self.assertEqual(res["evidence"]["accepted_head"], self.synced)
+
+    def test_missing_provenance_fails_closed(self):
+        """No server-derived provenance → cannot accept a remote ahead of local."""
+        res = self._assess(sync_provenance=None)
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_non_ancestor_recorded_head_fails_closed(self):
+        """AC7: provenance that does not prove ancestry is rejected."""
+        res = self._assess(
+            sync_provenance=sync_prov(
+                self.prior, self.synced, prior_is_ancestor=False, is_merge_sync=False,
+                reasons=["prior head is not an ancestor"],
+            )
+        )
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_force_pushed_history_fails_closed(self):
+        """AC8: a rewritten head (not a merge sync) stays protected."""
+        res = self._assess(
+            sync_provenance=sync_prov(
+                self.prior, self.synced, is_merge_sync=False, synced_is_merge=False,
+                reasons=["not a merge-based sync"],
+            )
+        )
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_provenance_for_other_commits_fails_closed(self):
+        """Provenance whose endpoints differ from the heads under assessment is rejected."""
+        res = self._assess(
+            sync_provenance=sync_prov("f" * 40, self.synced),
+        )
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_dirty_worktree_fails_closed(self):
+        """AC11: dirty worktrees remain protected."""
+        res = self._assess(porcelain_status=" M feature.txt\n")
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_live_owner_fails_closed(self):
+        """AC10: a live recorded owner is not a dead-session recovery."""
+        lock = make_dead_lock(self.tmp, session_pid=os.getpid(), pid=os.getpid())
+        res = self._assess(_lock=lock)
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_competing_claimant_fails_closed(self):
+        """AC13: a competing live lock blocks recovery."""
+        res = self._assess(
+            competing_live_locks=[{
+                "issue_number": ISSUE, "branch_name": BRANCH,
+                "worktree_path": "/some/other/wt", "pid": os.getpid(),
+            }]
+        )
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_wrong_branch_fails_closed(self):
+        """AC9: worktree on a different branch fails closed."""
+        res = self._assess(current_branch="fix/issue-8710-other")
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_wrong_identity_fails_closed(self):
+        res = self._assess(identity="intruder")
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_pr_head_mismatch_fails_closed(self):
+        """The open PR must sit at the synced remote head."""
+        res = self._assess(pr_head_sha="e" * 40)
+        self.assertEqual(res["outcome"], issue_lock_recovery.REFUSED)
+
+    def test_owning_pr_evidence_for_merge_sync(self):
+        res = self._assess()
+        ev = issue_lock_recovery.owning_pr_recovery_evidence(res)
+        self.assertIsNotNone(ev)
+        self.assertEqual(ev["pr_number"], PR_NUMBER)
+        self.assertEqual(ev["head_sha"], self.synced)
+        self.assertEqual(
+            ev["head_relation"],
+            issue_lock_recovery.HEAD_RELATION_REMOTE_MERGE_SYNCED,
+        )
+
+    def test_recovered_owning_pr_from_persisted_record(self):
+        res = self._assess()
+        record = issue_lock_recovery.build_recovery_record(res, recovered_at=future_ts(0))
+        lock = {"issue_number": ISSUE, "branch_name": BRANCH,
+                "dead_session_recovery": record}
+        rebuilt = issue_lock_recovery.recovered_owning_pr_from_lock(lock)
+        self.assertIsNotNone(rebuilt)
+        self.assertEqual(rebuilt["head_sha"], self.synced)
+        self.assertEqual(
+            rebuilt["head_relation"],
+            issue_lock_recovery.HEAD_RELATION_REMOTE_MERGE_SYNCED,
+        )
+
+
+class TestExistingRelationsUnchanged(unittest.TestCase):
+    """AC14/AC15: equal-head recovery still works; merge-sync did not weaken it."""
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp()
+        self.shas = build_merge_sync_repo(self.tmp)
+
+    def test_equal_head_recovery_still_sanctioned(self):
+        # Worktree at prior head; remote also at prior head → the #753 equal case.
+        prior = self.shas["prior"]
+        lock = make_dead_lock(self.tmp)
+        res = issue_lock_recovery.assess_dead_session_lock_recovery(
+            lock, issue_number=ISSUE, branch_name=BRANCH, worktree_path=self.tmp,
+            remote=REMOTE, org=ORG, repo=REPO, identity=IDENTITY, profile=PROFILE,
+            current_branch=BRANCH, porcelain_status="",
+            head_sha=prior, remote_head_sha=prior,
+            pr_head_sha=prior, pr_number=PR_NUMBER,
+            competing_live_locks=[], candidate_branches=[BRANCH],
+            current_pid=os.getpid(), remote_branch_exists=True,
+        )
+        self.assertEqual(res["outcome"], issue_lock_recovery.RECOVERY_SANCTIONED, res["reasons"])
+        self.assertEqual(
+            res["evidence"]["head_relation"], issue_lock_recovery.HEAD_RELATION_EQUAL,
+        )
+
+
+class TestUpdatePrWrapperPartialFailure(unittest.TestCase):
+    """AC5/AC16: the tool advances the remote head then refreshes the durable lock.
+
+    When the durable refresh fails after the remote advance, the tool must report a
+    partial lifecycle failure and NOT a fully successful synchronization. Exact PR-
+    head / base-head pinning is preserved (delegated to the real preflight, stubbed
+    here only to isolate the post-update lifecycle branch).
+    """
+
+    def setUp(self):
+        import gitea_mcp_server as gms  # noqa: E402
+        self.gms = gms
+        self._orig = {}
+
+        def _patch(name, value):
+            self._orig[name] = getattr(gms, name)
+            setattr(gms, name, value)
+
+        _patch("get_profile", lambda *a, **k: {
+            "allowed_operations": ["gitea.branch.push"],
+            "forbidden_operations": [],
+            "profile_name": "prgs-author",
+        })
+        _patch("_role_kind", lambda *a, **k: "author")
+        _patch("_profile_operation_gate", lambda *a, **k: None)
+        _patch("_permission_block_report", lambda *a, **k: {})
+        _patch("_resolve", lambda *a, **k: ("gitea.prgs.cc", ORG, REPO))
+        _patch("_verify_role_mutation_workspace", lambda *a, **k: None)
+        _patch("_get_workspace_porcelain", lambda *a, **k: "")
+        _patch("_canonical_local_git_root", lambda *a, **k: "/x")
+        _patch("_master_parity_block", lambda *a, **k: None)
+        _patch("_auth", lambda *a, **k: {"token": "x"})
+        _patch("repo_api_url", lambda *a, **k: "http://api")
+        _patch("_redact", lambda s: s)
+        _patch("_work_lease_claimant", lambda *a, **k: {
+            "username": IDENTITY, "profile": PROFILE,
+        })
+        _patch("_prove_author_ownership_for_pr", lambda *a, **k: {
+            "has_author_lock": True, "matched_issue": ISSUE,
+            "matched_via": "branch", "linked_issues": [ISSUE],
+            "recovered_owning_pr": None, "reasons": [],
+        })
+
+        # Real preflight is unit-tested elsewhere; stub it to isolate the
+        # post-update durable-lock lifecycle branch under test.
+        orig_pf = gms.pr_sync_status.assess_update_pr_branch_preflight
+        self._orig_pf = orig_pf
+        gms.pr_sync_status.assess_update_pr_branch_preflight = (
+            lambda *a, **k: {"mutation_allowed": True, "reasons": [], "performed": False}
+        )
+
+        # Sequence the two GET /pulls calls: OLD before update, NEW after.
+        self._pull_calls = {"n": 0}
+
+        def fake_api_request(method, url, auth, *a, **k):
+            m = method.upper()
+            if m == "GET" and url.endswith(f"/pulls/{PR_NUMBER}"):
+                self._pull_calls["n"] += 1
+                head = OLD if self._pull_calls["n"] == 1 else NEW1
+                return {
+                    "state": "open",
+                    "head": {"sha": head, "ref": BRANCH},
+                    "base": {"sha": BASE, "ref": "master"},
+                    "mergeable": True, "title": "t", "body": "b",
+                }
+            if m == "GET" and "/branches/" in url:
+                return {"commit": {"id": BASE}}
+            if m == "POST" and "/update" in url:
+                return {}
+            return {}
+
+        _patch("api_request", fake_api_request)
+
+    def tearDown(self):
+        for name, value in self._orig.items():
+            setattr(self.gms, name, value)
+        self.gms.pr_sync_status.assess_update_pr_branch_preflight = self._orig_pf
+
+    def _run(self):
+        return self.gms.gitea_update_pr_branch_by_merge(
+            pr_number=PR_NUMBER,
+            expected_pr_head_sha=OLD,
+            expected_base_head_sha=BASE,
+            remote=REMOTE,
+            worktree_path="/tmp/branches/wt-871",
+        )
+
+    def test_partial_failure_when_refresh_fails(self):
+        self._orig["apply_durable_lock_head_refresh"] = (
+            self.gms.issue_lock_store.apply_durable_lock_head_refresh
+        )
+        self.gms.issue_lock_store.apply_durable_lock_head_refresh = (
+            lambda **k: {"refreshed": False, "reasons": ["forced refresh failure"]}
+        )
+        try:
+            res = self._run()
+        finally:
+            self.gms.issue_lock_store.apply_durable_lock_head_refresh = (
+                self._orig["apply_durable_lock_head_refresh"]
+            )
+        self.assertTrue(res["performed"])
+        self.assertEqual(res["new_pr_head_sha"], NEW1)
+        self.assertFalse(res["success"])
+        self.assertTrue(res["partial_lifecycle_failure"])
+        self.assertFalse(res["durable_lock_refreshed"])
+
+    def test_full_success_when_refresh_succeeds(self):
+        self._orig["apply_durable_lock_head_refresh"] = (
+            self.gms.issue_lock_store.apply_durable_lock_head_refresh
+        )
+        self.gms.issue_lock_store.apply_durable_lock_head_refresh = (
+            lambda **k: {"refreshed": True, "read_after_write_ok": True,
+                         "new_head": NEW1, "reasons": ["ok"]}
+        )
+        try:
+            res = self._run()
+        finally:
+            self.gms.issue_lock_store.apply_durable_lock_head_refresh = (
+                self._orig["apply_durable_lock_head_refresh"]
+            )
+        self.assertTrue(res["success"])
+        self.assertTrue(res["performed"])
+        self.assertTrue(res["durable_lock_refreshed"])
+        self.assertTrue(res["fully_synchronized"])
+        self.assertEqual(res["new_pr_head_sha"], NEW1)
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,107 @@
+"""Documentation acceptance for the MCP restart governance ADR (#656).
+
+Enforces issue #656 acceptance criteria:
+
+* AC1 — policy document exists with an authorization matrix and the recorded
+  v1 decision (controller approval + automated safety gates).
+* AC2 — restart is stated as a last resort with enumerated narrower recoveries.
+* AC3 — a unilateral LLM full restart with affected sessions is forbidden.
+* AC4 — break-glass conditions are listed.
+* AC5 — the ADR is linked to #655, #652, #653, #630, #642, and is cross-linked
+  from the safety model and the web-console deployment boundary docs.
+"""
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+ADR = REPO_ROOT / "docs" / "architecture" / "mcp-restart-governance.md"
+ADR_BASENAME = "mcp-restart-governance.md"
+
+CROSS_LINK_DOCS = (
+    REPO_ROOT / "docs" / "safety-model.md",
+    REPO_ROOT / "docs" / "webui-deployment.md",
+)
+
+LINKED_ISSUES = ("#655", "#652", "#653", "#630", "#642")
+POLICY_IDS = ("RG-01", "RG-02", "RG-03", "RG-04", "RG-05", "RG-06", "RG-07", "RG-08")
+
+
+def _read(path: Path) -> str:
+    assert path.is_file(), f"missing {path.relative_to(REPO_ROOT)}"
+    return path.read_text(encoding="utf-8")
+
+
+def test_ac1_adr_exists_with_matrix_and_v1_decision():
+    text = _read(ADR)
+    lower = text.lower()
+    assert text.lstrip().startswith("#"), "ADR lacks a title"
+    assert "#656" in text
+    assert "authorization matrix" in lower
+    # The matrix is a real table with the worker and privileged roles.
+    for role in ("author", "reviewer", "merger", "reconciler", "controller",
+                 "operator", "admin"):
+        assert role in lower, f"authorization matrix missing role {role!r}"
+    # Recorded v1 decision.
+    assert "restart-governance/v1" in text
+    assert "controller approval" in lower and "automated safety gates" in lower
+
+
+def test_ac2_restart_is_last_resort_with_narrower_recoveries():
+    text = _read(ADR)
+    lower = text.lower()
+    assert "last resort" in lower
+    # Enumerated narrower recoveries precede full restart on the ladder.
+    for rung in ("reconnect", "rebind", "scoped restart", "full restart",
+                 "host"):
+        assert rung in lower, f"recovery ladder missing rung {rung!r}"
+
+
+def test_ac3_forbids_unilateral_llm_full_restart_with_affected_sessions():
+    text = _read(ADR)
+    lower = text.lower()
+    assert "forbidden" in lower
+    assert "llm" in lower and "restart" in lower
+    assert "unilateral" in lower
+    # A worker role must not perform or authorize full/host restart.
+    assert "must not" in lower
+
+
+def test_ac4_break_glass_conditions_listed():
+    text = _read(ADR)
+    lower = text.lower()
+    assert "break-glass" in lower
+    assert "incident" in lower
+    assert "audit" in lower
+
+
+def test_ac5_adr_links_issue_lineage():
+    text = _read(ADR)
+    for issue in LINKED_ISSUES:
+        assert issue in text, f"ADR must link issue {issue}"
+
+
+def test_ac5_safety_model_and_deployment_cross_link_adr():
+    for path in CROSS_LINK_DOCS:
+        text = _read(path)
+        assert ADR_BASENAME in text, (
+            f"{path.relative_to(REPO_ROOT)} must cross-link {ADR_BASENAME} "
+            f"(issue #656 acceptance criterion 5)"
+        )
+
+
+def test_policy_ids_present_for_enforcement_code():
+    text = _read(ADR)
+    for pid in POLICY_IDS:
+        assert pid in text, f"policy id {pid} missing from ADR"
+
+
+def test_failure_behavior_denies_on_ambiguity():
+    text = _read(ADR)
+    lower = text.lower()
+    assert "ambiguous" in lower and "deny" in lower
+
+
+def test_cross_links_do_not_embed_secrets():
+    for path in (ADR,) + CROSS_LINK_DOCS:
+        text = _read(path)
+        for marker in ("ghp_", "BEGIN PRIVATE KEY", "Authorization: Bearer"):
+            assert marker not in text, f"{path} contains {marker!r}"
@@ -134,13 +134,35 @@ class TestClassification(unittest.TestCase):
        self.assertEqual(cls, wca.CLASS_ACTIVE_OPEN_PR)
        self.assertFalse(wca.is_removable(cls))

-    def test_stale_clean_issue_worktree_removable(self):
-        # Scenario 5: clean issue worktree, TTL expired, no lock -> removable.
+    def test_stale_clean_issue_worktree_needs_merged_pr_proof(self):
+        # Scenario 5 (#858): age is not proof that the branch landed, so a
+        # TTL-expired issue worktree stays active work. Only authoritative
+        # merged-PR evidence makes it removable, which is what keeps a
+        # worktree holding unmerged commits from being reclaimed by age.
        cls = wca.classify_worktree(
            workflow_type=wca.WORKFLOW_ISSUE_WORK,
            is_dirty=False,
            ttl_expired=True,
        )
+        self.assertEqual(cls, wca.CLASS_ACTIVE_ISSUE_WORK)
+        self.assertFalse(wca.is_removable(cls))
+
+        cls = wca.classify_worktree(
+            workflow_type=wca.WORKFLOW_ISSUE_WORK,
+            is_dirty=False,
+            ttl_expired=True,
+            merged_pr_cleanup={"proven": True},
+        )
+        self.assertEqual(cls, wca.CLASS_CLEAN_STALE_REMOVABLE)
+        self.assertTrue(wca.is_removable(cls))
+
+    def test_stale_clean_conflict_fix_worktree_removable(self):
+        # conflict_fix keeps the original TTL rule; #858 changed issue work only.
+        cls = wca.classify_worktree(
+            workflow_type=wca.WORKFLOW_CONFLICT_FIX,
+            is_dirty=False,
+            ttl_expired=True,
+        )
        self.assertEqual(cls, wca.CLASS_CLEAN_STALE_REMOVABLE)
        self.assertTrue(wca.is_removable(cls))

@@ -34,7 +34,11 @@ import subprocess
 from datetime import datetime, timezone
 from typing import Any

-from merged_cleanup_reconcile import branch_worktree_folder, read_local_worktree_state
+from merged_cleanup_reconcile import (
+    branch_worktree_folder,
+    is_head_ancestor_of_ref,
+    read_local_worktree_state,
+)
 from reviewer_worktree import parse_dirty_tracked_files, REVIEW_WORKTREE_RE

 PROTECTED_BRANCHES = frozenset({"master", "main", "dev"})
@@ -67,6 +71,14 @@ REMOVABLE_CLASSES = frozenset(
    {CLASS_CLEAN_STALE_REMOVABLE, CLASS_DETACHED_REVIEW_LEFTOVER}
 )

+# Merged-PR linkage outcomes for issue worktrees (#858). Only ``LINKAGE_MERGED``
+# is ownership proof; every other outcome leaves the worktree protected.
+LINKAGE_MERGED = "merged_pr"
+LINKAGE_OPEN = "open_pr"
+LINKAGE_NONE = "no_owning_pr"
+LINKAGE_AMBIGUOUS = "ambiguous"
+LINKAGE_UNKNOWN = "unknown"
+
 _ISSUE_REF_RE = re.compile(r"issue-(\d+)", re.IGNORECASE)
 _ISSUE_BRANCH_PREFIXES = ("feat/", "fix/", "docs/", "chore/")

@@ -169,6 +181,186 @@ def is_ttl_expired(
    return (now_dt - last).total_seconds() > ttl_hours * 3600.0


+def build_pr_index(prs: list[dict[str, Any]] | None) -> dict[str, list[dict[str, Any]]]:
+    """Index PR records by head branch for deterministic worktree linkage (#858).
+
+    Accepts Gitea PR payloads (``head`` as a dict) and pre-flattened records
+    (``head_branch``/``head_sha``). Records without a usable head branch or
+    number are dropped rather than guessed at, so a branch is only ever linked
+    to a PR the caller actually proved.
+    """
+    index: dict[str, list[dict[str, Any]]] = {}
+    for pr in prs or []:
+        head = pr.get("head")
+        if isinstance(head, dict):
+            head_branch = head.get("ref")
+            head_sha = head.get("sha")
+        else:
+            head_branch = pr.get("head_branch") or (head if isinstance(head, str) else None)
+            head_sha = pr.get("head_sha")
+        number = pr.get("number")
+        if not head_branch or number is None:
+            continue
+        try:
+            pr_number = int(number)
+        except (TypeError, ValueError):
+            continue
+        index.setdefault(str(head_branch).strip(), []).append(
+            {
+                "pr_number": pr_number,
+                "head_branch": str(head_branch).strip(),
+                "head_sha": head_sha,
+                "merged": bool(pr.get("merged") or pr.get("merged_at")),
+                "state": pr.get("state"),
+            }
+        )
+    return index
+
+
+def resolve_owning_pr(
+    *,
+    branch: str | None,
+    pr_index: dict[str, list[dict[str, Any]]] | None,
+) -> dict[str, Any]:
+    """Resolve the single PR that owns ``branch``, failing closed when unclear.
+
+    Ownership is only ``LINKAGE_MERGED`` when exactly one PR claims the branch
+    and that PR is merged. Several distinct PRs on one branch is a competing
+    claim (``LINKAGE_AMBIGUOUS``), and a still-open owner is reported as
+    ``LINKAGE_OPEN`` — both keep the worktree protected while still exposing
+    the PR number the audit resolved.
+    """
+    if pr_index is None:
+        return {
+            "status": LINKAGE_UNKNOWN,
+            "pr_number": None,
+            "candidate_pr_numbers": [],
+            "reasons": ["live PR state was not supplied; ownership unproven"],
+        }
+    branch_name = (branch or "").strip()
+    if not branch_name:
+        return {
+            "status": LINKAGE_UNKNOWN,
+            "pr_number": None,
+            "candidate_pr_numbers": [],
+            "reasons": ["worktree has no attached branch; ownership unproven"],
+        }
+
+    candidates = list(pr_index.get(branch_name) or [])
+    numbers = sorted({c["pr_number"] for c in candidates})
+    if not candidates:
+        return {
+            "status": LINKAGE_NONE,
+            "pr_number": None,
+            "candidate_pr_numbers": [],
+            "reasons": [f"no PR claims branch '{branch_name}'"],
+        }
+    if len(numbers) > 1:
+        return {
+            "status": LINKAGE_AMBIGUOUS,
+            "pr_number": None,
+            "candidate_pr_numbers": numbers,
+            "reasons": [
+                f"branch '{branch_name}' is claimed by competing PRs {numbers}; "
+                "ownership is ambiguous"
+            ],
+        }
+
+    owner = candidates[0]
+    pr_number = owner["pr_number"]
+    if owner.get("head_branch") != branch_name:
+        return {
+            "status": LINKAGE_UNKNOWN,
+            "pr_number": pr_number,
+            "candidate_pr_numbers": numbers,
+            "reasons": [
+                f"PR #{pr_number} head branch '{owner.get('head_branch')}' does not "
+                f"match worktree branch '{branch_name}'"
+            ],
+        }
+    if not owner.get("merged"):
+        return {
+            "status": LINKAGE_OPEN,
+            "pr_number": pr_number,
+            "candidate_pr_numbers": numbers,
+            "pr_head_sha": owner.get("head_sha"),
+            "reasons": [f"owning PR #{pr_number} is not merged"],
+        }
+    return {
+        "status": LINKAGE_MERGED,
+        "pr_number": pr_number,
+        "candidate_pr_numbers": numbers,
+        "pr_head_sha": owner.get("head_sha"),
+        "reasons": [],
+    }
+
+
+def assess_merged_pr_worktree_cleanup(
+    *,
+    linkage: dict[str, Any] | None,
+    head_sha: str | None,
+    head_in_master: bool | None,
+    is_dirty: bool,
+    has_open_pr: bool,
+    has_active_lease: bool,
+    has_active_issue_lock: bool,
+    is_protected: bool,
+    has_live_session: bool = False,
+) -> dict[str, Any]:
+    """Decide whether a merged issue worktree satisfies the full cleanup policy.
+
+    Every condition must be independently proven: conclusive merged-PR
+    ownership, agreement between the worktree branch and the PR head branch,
+    containment of the worktree head in authoritative master (which is what
+    proves no unmerged commits remain), absence of any open/competing PR,
+    lease, issue lock, or live session, a clean tree, and a worktree that is
+    not the protected control checkout. Anything unknown blocks.
+    """
+    link = linkage or {
+        "status": LINKAGE_UNKNOWN,
+        "pr_number": None,
+        "reasons": ["no linkage assessment supplied"],
+    }
+    status = link.get("status")
+    reasons: list[str] = []
+
+    if status != LINKAGE_MERGED:
+        reasons.extend(
+            link.get("reasons") or ["owning PR could not be conclusively identified"]
+        )
+    if is_protected:
+        reasons.append("worktree is protected or the stable control checkout")
+    if is_dirty:
+        reasons.append("worktree has uncommitted changes")
+    if has_open_pr:
+        reasons.append("worktree branch has an open PR")
+    if has_active_lease:
+        reasons.append("worktree has an active lease")
+    if has_active_issue_lock:
+        reasons.append("an active issue lock references this branch")
+    if has_live_session:
+        reasons.append("a live process or session is using this worktree")
+    if not head_sha:
+        reasons.append("worktree head sha is unknown")
+    if head_in_master is None:
+        reasons.append("containment of the worktree head in master is unknown")
+    elif not head_in_master:
+        reasons.append(
+            "worktree head is not contained in authoritative master "
+            "(unmerged commits remain)"
+        )
+
+    proven = not reasons
+    return {
+        "linkage_status": status,
+        "pr_number": link.get("pr_number"),
+        "pr_head_sha": link.get("pr_head_sha"),
+        "head_in_master": head_in_master,
+        "proven": proven,
+        "block_reasons": reasons,
+    }
+
+
 def classify_worktree(
    *,
    workflow_type: str,
@@ -181,6 +373,8 @@ def classify_worktree(
    ttl_expired: bool = False,
    is_protected: bool = False,
    metadata_known: bool = True,
+    merged_pr_cleanup: dict[str, Any] | None = None,
+    has_live_session: bool = False,
 ) -> str:
    """Classify a worktree, safety-first: any preservation signal wins.

@@ -199,6 +393,8 @@ def classify_worktree(
        return CLASS_ACTIVE_ISSUE_WORK  # never auto-deleted (criterion 8)
    if has_active_issue_lock:
        return CLASS_ACTIVE_ISSUE_WORK
+    if has_live_session:
+        return CLASS_ACTIVE_ISSUE_WORK  # a live session still owns this tree
    if not metadata_known or workflow_type == WORKFLOW_UNKNOWN:
        return CLASS_UNSAFE_UNKNOWN  # never auto-deleted without proof

@@ -207,7 +403,15 @@ def classify_worktree(
        if is_detached or branch_gone:
            return CLASS_DETACHED_REVIEW_LEFTOVER
        return CLASS_CLEAN_STALE_REMOVABLE
-    # issue_work / conflict_fix: only removable once the TTL has expired.
+    if workflow_type == WORKFLOW_ISSUE_WORK:
+        # #858: an issue worktree becomes removable only on authoritative
+        # merged-PR evidence satisfying the whole cleanup policy. Age alone
+        # never proves the branch landed, so TTL cannot qualify one by itself
+        # — otherwise a worktree holding unmerged commits would be reclaimed.
+        if (merged_pr_cleanup or {}).get("proven"):
+            return CLASS_CLEAN_STALE_REMOVABLE
+        return CLASS_ACTIVE_ISSUE_WORK
+    # conflict_fix: only removable once the TTL has expired.
    if ttl_expired:
        return CLASS_CLEAN_STALE_REMOVABLE
    return CLASS_ACTIVE_ISSUE_WORK
@@ -400,6 +604,20 @@ def remove_worktree(project_root: str, path: str) -> dict[str, Any]:
    }


+def head_contained_in_ref(
+    project_root: str, head_sha: str | None, ref: str | None
+) -> bool | None:
+    """Return True when ``head_sha`` is already contained in ``ref``.
+
+    Shares :mod:`merged_cleanup_reconcile`'s ancestry check so the audit and
+    the PR-scoped reconciler agree on what "already landed" means (#858).
+    Returns None when containment cannot be determined, which fails closed.
+    """
+    if not head_sha or not ref:
+        return None
+    return is_head_ancestor_of_ref(project_root, head_sha, ref)
+
+
 def _is_under_branches(project_root: str, path: str) -> bool:
    branches_root = os.path.join(os.path.abspath(project_root), "branches")
    return os.path.abspath(path or "").startswith(branches_root + os.sep)
@@ -413,16 +631,30 @@ def audit_branches_directory(
    active_issue_branches: set[str] | None = None,
    now: datetime | str | None = None,
    ttl_hours: float = DEFAULT_TTL_HOURS,
+    pr_index: dict[str, list[dict[str, Any]]] | None = None,
+    leased_issue_numbers: set[int] | None = None,
+    live_session_paths: set[str] | None = None,
+    master_ref: str | None = None,
 ) -> dict[str, Any]:
    """Classify every session-owned worktree under ``branches/``.

    Read-only: shells out to git for discovery and dirty state, then applies
    the pure classifier. Returns per-worktree classifications, counts, the
    list of removable candidates, and the ``git worktree list`` proof.
+
+    ``pr_index`` (see :func:`build_pr_index`) supplies the authoritative PR
+    ownership used to link issue worktrees to their merged PR (#858).
+    ``master_ref`` is the ref a worktree head must be contained in before it
+    can be considered landed. Both are optional and their absence only ever
+    fails closed: without them no issue worktree becomes removable.
    """
    open_pr_branches = open_pr_branches or set()
    leased_branches = leased_branches or set()
    active_issue_branches = active_issue_branches or set()
+    leased_issue_numbers = leased_issue_numbers or set()
+    live_session_paths = {
+        os.path.abspath(p) for p in (live_session_paths or set()) if p
+    }

    worktrees: list[dict[str, Any]] = []
    for entry in list_worktrees(project_root):
@@ -433,12 +665,42 @@ def audit_branches_directory(
        )
        dirty_state = read_worktree_dirty(path)
        is_dirty = bool(dirty_state.get("dirty"))
+        head_sha = entry.get("head")
+        linkage = resolve_owning_pr(branch=branch, pr_index=pr_index)
        metadata = build_worktree_metadata(
-            path=path, branch=branch, head_sha=entry.get("head")
+            path=path,
+            branch=branch,
+            head_sha=head_sha,
+            pr_number=linkage.get("pr_number"),
        )
        has_open_pr = bool(branch) and branch in open_pr_branches
-        has_active_lease = bool(branch) and branch in leased_branches
+        # A lease on issue N protects that issue's own work worktree. It must
+        # not incidentally protect a baseline/review scratch tree that merely
+        # carries the same issue marker in its name, which would change the
+        # classification of worktrees this policy does not own.
+        has_active_lease = (bool(branch) and branch in leased_branches) or (
+            metadata["workflow_type"] == WORKFLOW_ISSUE_WORK
+            and metadata.get("issue_number") is not None
+            and metadata["issue_number"] in leased_issue_numbers
+        )
        has_active_lock = bool(branch) and branch in active_issue_branches
+        has_live_session = bool(path) and os.path.abspath(path) in live_session_paths
+        head_in_master = (
+            head_contained_in_ref(project_root, head_sha, master_ref)
+            if master_ref
+            else None
+        )
+        merged_pr_cleanup = assess_merged_pr_worktree_cleanup(
+            linkage=linkage,
+            head_sha=head_sha,
+            head_in_master=head_in_master,
+            is_dirty=is_dirty,
+            has_open_pr=has_open_pr,
+            has_active_lease=has_active_lease,
+            has_active_issue_lock=has_active_lock,
+            is_protected=is_protected,
+            has_live_session=has_live_session,
+        )
        ttl_expired = is_ttl_expired(
            last_used_at=metadata.get("last_used_at"), now=now, ttl_hours=ttl_hours
        )
@@ -452,6 +714,8 @@ def audit_branches_directory(
            branch_gone=branch is None and not entry.get("detached"),
            ttl_expired=ttl_expired,
            is_protected=is_protected,
+            merged_pr_cleanup=merged_pr_cleanup,
+            has_live_session=has_live_session,
        )
        metadata["cleanup_eligibility"] = classification
        worktrees.append(
@@ -463,7 +727,10 @@ def audit_branches_directory(
                "has_open_pr": has_open_pr,
                "has_active_lease": has_active_lease,
                "has_active_issue_lock": has_active_lock,
+                "has_live_session": has_live_session,
                "is_protected": is_protected,
+                "merged_pr_linkage": linkage,
+                "merged_pr_cleanup": merged_pr_cleanup,
                "classification": classification,
                "removable": is_removable(classification),
            }
Author	SHA1	Message	Date
sysadmin	cc7dc8ac14	Merge pull request 'fix(author): refresh durable issue-lock head after branch sync; recover merge-sync-drifted dead-session locks (Closes #871 )' (#874 ) from fix/issue-871-durable-lock-head-refresh into master	2026-07-24 03:04:24 -05:00
jcwalker3	e151759212	Merge branch 'master' into fix/issue-871-durable-lock-head-refresh	2026-07-24 02:42:52 -05:00
sysadmin	60df5087e9	Merge pull request 'docs(governance): MCP restart governance and authorization policy (Closes #656 )' (#857 ) from docs/issue-656-mcp-restart-governance into master	2026-07-24 02:26:02 -05:00
jcwalker3	0088ecaf00	Merge branch 'master' into docs/issue-656-mcp-restart-governance	2026-07-24 02:07:17 -05:00
sysadminandClaude Opus 4.8	5d59c57c98	fix(author): refresh durable issue-lock head after branch sync; recover merge-sync-drifted dead-session locks (#871 ) `gitea_update_pr_branch_by_merge` advanced a PR's remote head but never advanced the linked durable issue lock's recorded head. After the owning session died the drifted lock became unrecoverable and no further synchronization was possible (PR #866 / issue #855). Write-side (prevents future drift): - issue_lock_store.assess/apply_durable_lock_head_refresh: on a successful sync, CAS-refresh the durable lock's recorded head from the exact expected PR head to the resulting head, re-verifying repo/issue/branch/worktree/ identity/profile/live-session ownership, with read-after-write verification. - gitea_update_pr_branch_by_merge now refreshes the lock after the remote advance and reports a PARTIAL LIFECYCLE FAILURE (success=False) when the refresh fails, instead of falsely reporting a full synchronization. Read-side (recovers already-drifted locks): - issue_lock_worktree.read_merge_sync_provenance: server-side git observation proving a remote head is a sanctioned base-into-branch merge that preserved the branch mainline back to the recorded head. - issue_lock_recovery: new HEAD_RELATION_REMOTE_MERGE_SYNCED accepts a dead-session lock whose recorded head is a strict merge-sync ancestor of the live PR head — and only that. Rewrites, rebases, force-pushes, non-ancestor heads, dirty worktrees, live/competing owners, and wrong repo/issue/branch/ identity/profile all stay protected. No existing exact-head, branch-protection, parity, workspace, identity, role, or mutation-safety gate is weakened. All provenance is server-derived; nothing is reachable from an MCP caller. Tests: tests/test_issue_871_durable_lock_head_refresh.py (32 cases) covering first/second sync, CAS, ownership, partial-failure, merge-sync recovery happy-path and every fail-closed branch. Full suite: 4789 passed, 13 pre- existing baseline failures unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]> Claude-Session: https://claude.ai/code/session_01FZPyVh2DGczQrDxtqwGH5p	2026-07-24 02:56:57 -04:00
sysadmin	89657a06c4	Merge pull request 'fix(author): harden dirty-session rebind inventory and journal identity (#868 )' (#869 ) from fix/issue-868-dirty-rebind-inventory-journal into master	2026-07-24 01:00:53 -05:00
sysadmin	ba3ea3012c	fix(author): harden dirty-session rebind inventory and journal identity (#868 ) Complete dirty-inventory revalidation immediately before and after bind_session_lock so added, removed, or renamed paths fail closed. Persist and validate full recovery-journal operation identity (remote, org, repo, claimant identity, claimant profile) on execute, resume, retry, and already_rebound. Add focused regression coverage and the reconciler success-path integration test. Closes #868.	2026-07-24 01:13:50 -04:00
sysadmin	ef14622ba0	Merge pull request 'feat(author): dirty-preserving same-claimant author-session rebind (#864 )' (#865 ) from fix/issue-864-dirty-same-claimant-session-rebind into master	2026-07-23 23:55:01 -05:00
jcwalker3	a3f8f67c93	feat(author): add dirty-preserving same-claimant author-session rebind (Closes #864 ) Introduce an explicit, fail-closed recovery operation that rebinds a live author session to an already-registered dirty issue worktree when the durable lock still belongs to the same identity/profile and the recorded owner PID is provably dead. Ordinary locking remains clean-worktree-only; this path updates only stale lock/session provenance, preserves every dirty byte under fingerprint pins, and grants create-PR-sanctioned provenance without remote sync or recovery worktrees. Also stop treating dead-owner session pointers as live mutation workspace bindings so a stale dead-owner pointer cannot poison unrelated author work.	2026-07-23 22:54:15 -05:00
sysadmin	6d0015cabc	Merge pull request 'fix(worktree-audit): make cleanup audit merged-PR aware for issue worktrees (Closes #858 )' (#859 ) from fix/issue-858-audit-merged-pr-aware into master	2026-07-23 22:02:22 -05:00
sysadminandClaude Opus 4.8	fe259e6d38	fix(worktree-audit): make cleanup audit merged-PR aware for issue worktrees (Closes #858 ) gitea_audit_worktree_cleanup had no PR linkage. Issue worktrees therefore reported pr_number=null and classified as active_issue_work with removable=false permanently, even once their PR was merged and the head was already contained in master. Observed on live master `9301739910`: 42 issue_work worktrees, 0 removable, 0 with pr_number populated, while gitea_reconcile_merged_cleanups reported the same worktree safe to remove. Two independent gaps caused it: * build_worktree_metadata was never given a pr_number, and only open PRs were fetched, so no owning-PR evidence existed at all. * clean_stale_removable was unreachable for issue_work: it required ttl_expired, derived from a last_used_at that nothing populates, and is_ttl_expired fail-safes to False when the timestamp is unknown. This adds deterministic merged-PR linkage and gates removal on the complete cleanup policy: * build_pr_index / resolve_owning_pr link a worktree branch to exactly one owning PR. Competing PRs on one branch, a still-open owner, a head-branch mismatch, or missing PR state all fail closed while still reporting the resolved pr_number. * assess_merged_pr_worktree_cleanup requires all of: conclusive merged ownership, branch agreement, containment of the head in authoritative master, no open/competing PR, no active lease, no issue lock, no live session, a clean tree, and a non-protected checkout. Unknown state blocks. * Containment reuses merged_cleanup_reconcile.is_head_ancestor_of_ref so the audit and the PR-scoped reconciler agree on what "already landed" means. Lease evidence is now supplied. audit_branches_directory already accepted leased_branches but the MCP tool never passed it, so has_active_lease was false for every worktree in a live run. That was inert only while issue worktrees could never become removable; it is wired to authoritative control-plane leases here, scoped so a lease on issue N protects that issue's work worktree and not a baseline or review tree merely named after it. Issue work no longer becomes removable on TTL age alone, since age is not proof that a branch landed and would otherwise reclaim a worktree holding unmerged commits. conflict_fix keeps its existing TTL behaviour, and review, baseline, merge-simulation, detached, dirty, open-PR, and protected classifications are unchanged. The assessor still performs no deletion and gains no cleanup mutation. This is assessor-side only and does not implement the PR-scoped executor or the expired-lease reclaim policy tracked separately by #855. Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>	2026-07-23 21:19:32 -04:00
jcwalker3	dc99c15ffa	Merge branch 'master' into docs/issue-656-mcp-restart-governance	2026-07-23 19:53:16 -05:00
sysadmin	9301739910	Merge pull request 'feat(webui): workflow-event and conversation timeline model (Closes #637 )' (#849 ) from feat/issue-637-timeline-model into master	2026-07-23 19:33:22 -05:00
sysadminandClaude Opus 4.8	9f759150b8	docs(governance): correct linked-issue descriptions in restart ADR (#656 ) The Related section and cross-reference lines described #652, #653, #630, #642, and #591 by roles they do not hold. Align each description with the linked issue's actual title and scope: - #652 is the Control Plane Web Console product vision (restart controls live in its capability area A), not a restart-specific vision. - #653 is the console phased-delivery roadmap; restart controls are Phase 2. - #630 is the manual process-kill contamination guard, not the coordinator; the coordinator remains an unimplemented later child of #655. - #642 is the sanctioned restart / graceful reload console UX. - #591 is auto-restart on master advance (closed); only #584 is transport-flap reconnect. They were previously collapsed into one transport-recovery label. Documentation-only wording change. Policy IDs RG-01..RG-08, the policy version restart-governance/v1, the authorization matrix, and every normative statement are unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>	2026-07-23 19:18:47 -04:00
sysadmin	347464a057	Merge branch 'master' into docs/issue-656-mcp-restart-governance	2026-07-23 19:17:05 -04:00
sysadminandClaude Opus 4.8	1301a57de4	docs(governance): MCP restart governance and authorization policy (#656 ) Adds docs/architecture/mcp-restart-governance.md, the restart-governance/v1 ADR defining who may restart the MCP control plane and under what conditions. - Recovery ladder (reconnect -> rebind -> scoped restart -> full restart -> host) with restart stated as the last resort. - Authorization matrix across author/reviewer/merger/reconciler/controller/ operator/admin; no LLM worker role may perform or authorize a full or host restart. - v1 authority decision recorded: controller approval + automated safety gates; quorum deferred to a superseding ADR. - Break-glass path with pre-declared incident and mandatory post-hoc audit. - Ambiguous policy state denies restart. - Stable policy IDs RG-01..RG-08 for later enforcement code to bind to. Cross-links the ADR from docs/safety-model.md and docs/webui-deployment.md, and adds tests/test_mcp_restart_governance_docs.py asserting acceptance criteria 1-5. Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>	2026-07-23 19:16:28 -04:00