fix(lib): authorize relayed sync by owned drive, not peer identity

Real-time updates only crossed on the first sync. A server holding your
drive authenticates over Iroh as its own node agent, not yours, so
`import_sync_push` / `admitted_for_drive` — which gated writes on the
transport peer's `check_write` — dropped every update the server relayed
back ("agent sngJDX has no write access to drive 8GMX"). Initial sync
slipped through only via the "drive doesn't exist yet" bootstrap.

Replace the transport-identity gate with `may_accept_drive_write`: accept
when the peer can write the drive, OR — when we dialed the peer
(`trust_owned` / `initiated_by_us`) — when our own agent can. A peer that
dials into us gets no relaxation. This is the drive owner acting as the
authority over their own replica, from a peer they chose to connect to.

Remove `is_same_agent_as_ours` and the "same-agent only" rule entirely;
the honest-error no longer blames a legitimate server as "a different
account". New regression test covers the relay case both directions.

Also persist peer relay + direct addresses (captured from a live
connection) and re-dial with a full NodeAddr, so reconnecting doesn't
hinge on a pkarr lookup that times out behind restrictive NAT; and record
`last_synced` per known peer.

Claude-Session: https://claude.ai/code/session_01VddwtxveM8Zqsf765aQSHY

lib/src/sync/engine.rs

@@ -199,7 +199,12 @@ pub async fn handle_frame(
 
         protocol::tag::SYNC_PUSH => {
             if let Some(push) = protocol::decode_sync_push(payload) {
-                let (_count, mut blob_requests) = import_sync_push(&push, store, agent).await;
+                // handle_frame serves connections dialed *into* us (accept side,
+                // WS): no owned-drive relaxation — the sender must itself hold
+                // write rights. The dial side calls import_sync_push directly
+                // with trust_owned=true.
+                let (_count, mut blob_requests) =
+                    import_sync_push(&push, store, agent, false).await;
                 let mut responses = vec![protocol::encode_sync_ok(&push.drive)];
                 responses.append(&mut blob_requests);
                 responses
@@ -906,25 +911,67 @@ pub async fn handle_sync_vv_filtered(
     frames
 }
 
+/// Whether an incoming write to `drive_resource` should be accepted.
+///
+/// The direct case: the peer that sent it can itself write the drive.
+///
+/// The relayed case (`trust_owned`): a peer we *chose to connect to* — a server
+/// that stores our drive, another of our devices — authenticates as its OWN
+/// agent, not ours, yet is faithfully relaying updates to a drive WE own. Gating
+/// on the transport peer's identity would reject every such update (this is why
+/// a phone stops receiving a browser's edits once its drive already exists on
+/// the server). So when we initiated the connection, we also accept updates to
+/// drives our own agent may write — the drive owner acting as the authority over
+/// their own replica. We never relax this for connections dialed *into* us: a
+/// stranger who dials us does not get to write our drives just because we own
+/// them.
+pub(crate) async fn may_accept_drive_write(
+    store: &Db,
+    drive_resource: &crate::Resource,
+    for_agent: &crate::agents::ForAgent,
+    trust_owned: bool,
+) -> bool {
+    if crate::hierarchy::check_write(store, drive_resource, for_agent)
+        .await
+        .is_ok()
+    {
+        return true;
+    }
+    if trust_owned {
+        if let Ok(own) = store.get_default_agent() {
+            let own_agent = crate::agents::ForAgent::from(own);
+            if crate::hierarchy::check_write(store, drive_resource, &own_agent)
+                .await
+                .is_ok()
+            {
+                return true;
+            }
+        }
+    }
+    false
+}
+
 /// Import resources from a SYNC_PUSH message into the local store.
-/// When called from handle_frame (server receiving from a peer), `for_agent` is checked
-/// for write access to the drive. When called locally (e.g. client importing), pass `Sudo`.
+///
+/// `for_agent` is the identity the sending peer proved. `trust_owned` is true
+/// when WE dialed this peer, which lets a relayed push to a drive we own through
+/// even though the relaying peer is a different agent (see
+/// [`may_accept_drive_write`]). When importing locally, pass `Sudo`.
 pub async fn import_sync_push(
     push: &protocol::DecodedSyncPush,
     store: &Db,
     for_agent: &crate::agents::ForAgent,
+    trust_owned: bool,
 ) -> (usize, Vec<Vec<u8>>) {
     // Check write access to the drive
     let drive_subject = crate::Subject::from_raw(&push.drive, store.get_base_domain().as_deref());
     if let Ok(drive_resource) = store.get_resource(&drive_subject).await {
-        if crate::hierarchy::check_write(store, &drive_resource, for_agent)
-            .await
-            .is_err()
-        {
+        if !may_accept_drive_write(store, &drive_resource, for_agent, trust_owned).await {
             tracing::warn!(
-                "import_sync_push: agent {:?} has no write access to drive {}",
+                "import_sync_push: agent {:?} has no write access to drive {} (trust_owned={})",
                 for_agent,
-                push.drive
+                push.drive,
+                trust_owned
             );
             return (0, vec![]);
         }

lib/src/sync/iroh_e2e.rs

@@ -422,7 +422,7 @@ async fn e2e_engine_pull_after_iroh_bulk_sync() {
         if frame.first() == Some(&crate::sync::protocol::tag::SYNC_PUSH) {
             if let Some(push) = crate::sync::protocol::decode_sync_push(&frame[1..]) {
                 let (count, _) =
-                    crate::sync::engine::import_sync_push(&push, &pair.db_b, &ForAgent::Sudo).await;
+                    crate::sync::engine::import_sync_push(&push, &pair.db_b, &ForAgent::Sudo, false).await;
                 imported += count;
             }
         }
@@ -595,7 +595,7 @@ async fn peer_sync_says_why_when_a_different_agent_may_read_nothing() {
     let error = result.expect_err("an empty sync must not report success");
     let message = error.to_string();
     assert!(
-        message.contains("different account"),
+        message.contains("nothing synced"),
         "the failure must say why, got: {message}"
     );
 
@@ -736,6 +736,7 @@ async fn a_peer_cannot_forge_a_third_agents_resource() {
         &db_server,
         &ForAgent::AgentSubject(eve.subject.clone()),
         &victim.subject.to_string(),
+        false,
         &mut cache,
     )
     .await;
@@ -750,6 +751,7 @@ async fn a_peer_cannot_forge_a_third_agents_resource() {
         &db_server,
         &ForAgent::AgentSubject(eve.subject.clone()),
         &eve.subject.to_string(),
+        false,
         &mut cache,
     )
     .await;