@@ -48,6 +48,17 @@ advancement work remains active.
   replay that observation; changed content conflicts only with the same monitor
   identity; another due monitor receives an independent no-spend receipt.
   Shipped turn-only receipts remain replayable for their original monitor.
+- A target-only, turn-scoped executed retry retains the resolved Todo identity of an existing
+  poll transaction when that same active Monitor is no longer due. Current
+  target selection and the existing receipt path locate the operation; only the
+  typed transaction owner may verify its scope, fingerprint and frozen admission.
+  The transport rechecks that Todo-scoped operation's presence under the same
+  quota admission as the native receipt read. A prior no-effect abort cannot turn
+  this recovery route into a new poll. Committed replay and provider-committed
+  pending recovery grant no admission to a new not-due observation. Caller target, hash, intent and lease proof
+  remain unchanged. Explicit Todo retries and historical target-only wire shapes
+  retain their existing paths; current replacement selection is not evidence of
+  an archived Monitor's original identity.
 - A receipt-bound monitor remains strict: another monitor cannot be substituted
   for the Turn's settlement Todo. Multiple auxiliary receipts never change the
   already-bound settlement identity.
@@ -319,6 +330,14 @@ using a complete read-only snapshot with disposable File/SQLite/PostgreSQL arms.
   `target_key` 摘要建立身份。精确重试只重放该观察；同一 monitor 下内容变化
   只与该 monitor 冲突；另一个到期 monitor 获得独立的不计费回执。已发布的
   Turn-only 旧回执仍可对原 monitor 重放。
+- 仅用 target 的 turn-scoped 执行重试，在同一个 active Monitor 已不再到期时保留已有 poll
+  事务解析出的 Todo 身份。当前 target 选择和既有回执路径只定位原操作；作用域、
+  指纹与冻结准入仍由 typed 事务 owner 校验。transport 在 native 回执读取的同一
+  quota admission 内重查 Todo-scoped 操作仍存在；之前的 no-effect abort 不能把
+  恢复路由转成新 poll。重放已提交操作或恢复 provider 已提交的 pending 操作，
+  不提供新的未到期观察准入。调用者的 target、hash、intent
+  和租约证明保持原样。显式 Todo 重试及历史 target-only wire 保留原路径；当前
+  replacement 选择不能证明已归档 Monitor 的原身份。
 - 若 heartbeat 本身绑定的是 monitor，仍保持严格身份，不能把另一个 monitor
   替换为本 Turn 的结算 Todo；多个辅助回执也绝不改变既有结算身份。
 - 辅助观察无变化后，原 advancement Todo 继续保持选中；若观察发生重大变化，
 
@@ -142,6 +142,44 @@ def resolve_due_monitor_candidate(
     }
 
 
+def _monitor_poll_receipt_path(runtime_root: Path, goal_id: str, effect_id: str) -> Path:
+    return (runtime_root / "goals" / goal_id / "runs" / ".transactions" /
+            "quota-monitor-poll" / f"{hashlib.sha256(effect_id.encode()).hexdigest()[:24]}.json")
+
+
+def resolve_monitor_poll_target(
+    *, registry_path: Path | None, runtime_root: Path | None, goal_id: str,
+    target_key: str | None, before: dict[str, Any], turn_instance_id: str | None,
+    execute: bool, goal_ref: Mapping[str, Any] | None,
+) -> tuple[str | None, str | None]:
+    due = resolve_due_monitor_candidate(registry_path=registry_path, runtime_root=runtime_root,
+        goal_id=goal_id, todo_id=None, target_key=target_key)
+    if due:
+        return normalize_todo_id(due["todo_id"]), None
+    if not execute or runtime_root is None or not turn_instance_id or not target_key or registry_path is None:
+        return None, None
+    try:
+        item = resolve_monitor_todo_item(registry_path=registry_path, runtime_root=runtime_root,
+            goal_id=goal_id, target_key=target_key)
+    except ValueError:
+        return None, None
+    todo_id = normalize_todo_id(item.get("todo_id"))
+    effect_id = _monitor_poll_effect_id(runtime_root=runtime_root, goal_id=goal_id,
+        agent_id=quota_decision_agent_id(before), turn_instance_id=normalize_turn_instance_id(turn_instance_id),
+        todo_id=todo_id, target_key=target_key, goal_ref=goal_ref)
+    expected_effect = f"quota-monitor-poll:{goal_id}:{quota_decision_agent_id(before)}:{normalize_turn_instance_id(turn_instance_id)}:todo:{todo_id}"
+    if effect_id != expected_effect:
+        # Historical target/turn-only effects can have a null Todo on the wire.
+        # The provider's resolved Todo cannot rewrite their frozen fingerprint.
+        return None, None
+    # Existence is only a transport route to the original operation. TypeScript
+    # validates scope, fingerprint and frozen admission before replay/recovery.
+    # Without that operation, retain current due admission and the original wire.
+    if _monitor_poll_receipt_path(runtime_root, goal_id, effect_id).exists():
+        return todo_id, effect_id
+    return None, None
+
+
 def _decision_packet(
     before: dict[str, Any],
     *,
@@ -739,6 +777,7 @@ def record_quota_monitor_poll_for_decision(
     _index_lock_held: bool = False,
     status_reloader: Callable[[], dict[str, Any]] | None = None,
     goal_ref: Mapping[str, Any] | None = None,
+    recovery_effect_id: str | None = None,
 ) -> dict[str, Any]:
     del render_markdown
     normalized_turn_id = normalize_turn_instance_id(turn_instance_id)
@@ -855,6 +894,14 @@ def failure(
     def transact(
         source_admission: Mapping[str, Any] | None,
     ) -> tuple[dict[str, Any], dict[str, Any]]:
+        # Recheck the transport precondition inside the same quota admission as
+        # the native receipt read. A legal no-effect abort may have removed it
+        # since target selection; that must never turn recovery into a new poll.
+        if recovery_effect_id is not None and (
+            effect_id != recovery_effect_id or
+            not _monitor_poll_receipt_path(runtime_root, goal_id, effect_id).exists()
+        ):
+            raise ValueError("original Monitor poll transaction is unavailable; reconcile its original operation before retrying")
         common = {
             "effect_id": effect_id,
             "runtime_root": runtime_root,
@@ -876,8 +923,7 @@ def transact(
 
         # Validate explicit claim routing before quota reserves a pending effect.
         # Exact retries keep their frozen admission if registry membership changed.
-        receipt_path = (runtime_root / "goals" / goal_id / "runs" / ".transactions" /
-                        "quota-monitor-poll" / f"{hashlib.sha256(effect_id.encode()).hexdigest()[:24]}.json")
+        receipt_path = _monitor_poll_receipt_path(runtime_root, goal_id, effect_id)
         if next_claimed_by and registry_path is not None and not receipt_path.exists():
             plan_todo_authoring_scope(
                 command="create", role="agent", goal_id=goal_id,
 
@@ -38,7 +38,7 @@
     QUOTA_MONITOR_POLL_CLASSIFICATION as QUOTA_MONITOR_POLL_CLASSIFICATION,
     build_quota_monitor_poll_event as build_quota_monitor_poll_event,
     record_quota_monitor_poll_for_decision,
-    resolve_due_monitor_candidate,
+    resolve_monitor_poll_target,
 )
 from .control_plane.quota.blocked_retry import overlay_active_turn_retries
 from .control_plane.quota.recent_runs import (
@@ -1177,19 +1177,6 @@ def record_quota_monitor_poll(
     runtime_root = (
         Path(str(raw_runtime_root)).expanduser() if raw_runtime_root else None
     )
-    resolved_monitor = resolve_due_monitor_candidate(
-        registry_path=registry_path,
-        runtime_root=runtime_root,
-        goal_id=safe_goal_id,
-        todo_id=normalized_requested_todo_id,
-        target_key=target_key,
-    )
-    normalized_observation_todo_id = normalized_requested_todo_id or (
-        normalize_todo_id(resolved_monitor.get("todo_id"))
-        if resolved_monitor
-        else None
-    )
-
     def should_run(current_status: dict[str, Any]) -> dict[str, Any]:
         decision_status = current_status
         if bounded_research_frontier_projector is not None:
@@ -1225,6 +1212,14 @@ def should_run(current_status: dict[str, Any]) -> dict[str, Any]:
         )
 
     before = should_run(status_payload)
+    recovery_effect_id = None
+    normalized_observation_todo_id = normalized_requested_todo_id
+    if normalized_observation_todo_id is None:
+        normalized_observation_todo_id, recovery_effect_id = resolve_monitor_poll_target(
+            registry_path=registry_path, runtime_root=runtime_root, goal_id=safe_goal_id,
+            target_key=target_key, before=before, turn_instance_id=turn_instance_id,
+            execute=execute, goal_ref=goal_ref,
+        )
     auxiliary_settlement_todo = None
     if (
         normalized_receipt_todo_id
@@ -1282,6 +1277,7 @@ def should_run(current_status: dict[str, Any]) -> dict[str, Any]:
         turn_instance_id=turn_instance_id,
         status_reloader=status_reloader,
         goal_ref=goal_ref,
+        recovery_effect_id=recovery_effect_id,
     )
     continuation = result.get("turn_continuation") or {}
     if (