Der Permalink zeigt den Beitrag, den eine Antwort beantwortet (#1991)

Eine Antwort auf einen Beitrag aus einem anderen Netzwerk stand auf ihrer
eigenen Seite allein, über einer Zeile "Antwort an @user@host", die zum Konto
führte und nicht zu dem, was beantwortet wurde. Der Feed zeichnet diese Karte
seit dem 01.09. darüber; hier fehlte sie, ausgerechnet auf der Seite, auf der
ein geteilter Link landet. Die Montage einer Konversation stand dafür zweimal
im Renderer, weshalb die vierte Stufe hier schlicht vergessen war: sie steht
jetzt einmal.

Die Sichtbarkeit wird dabei gegen den Leser geprüft, nicht gegen den
Antwortenden, denn die Seite ist öffentlich: abgemeldet nur ein wirklich
öffentlicher Beitrag innerhalb der Aufbewahrungsgrenze, angemeldet der eigene
akzeptierte Follow. Weil die HTML-Seite jetzt Text zeigt, tragen ihn die
.md/.txt/.json/.xml-Geschwister mit, wie es die Antwort von draußen seit #1069
schon tut.

Diesen Text hat ein KI-Agent in meinem Namen geschrieben. Ich weiß, dass das
problematisch ist.

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

Author: wintermeyer

lib/vutuv/fediverse.ex

@@ -7820,6 +7820,40 @@ defmodule Vutuv.Fediverse do
         do: post.id
   end
 
+  @doc """
+  Whether a page open to **everyone** may show this cached post — the arm
+  `remote_post_readable?/2` deliberately does not have, because it answers for a
+  signed-in party and a public page has readers who are nobody.
+
+  Two halves, and both are already spelled in SQL by the two viewer-independent
+  public readers here (`Vutuv.Tags.Timeline.remote_posts_query/1` and
+  `recent_public_remote_posts/1`): outright `public` — never `unlisted`, whose
+  whole meaning is "keep me off discovery surfaces" — and still inside the
+  retention ceiling, which is the claim to hold somebody else's post at all, so
+  a row the sweep has not reached yet is not one to keep publishing.
+  """
+  def publicly_readable_remote_post?(%RemotePost{expires_at: %DateTime{} = expires} = post),
+    do: RemotePost.public?(post) and DateTime.after?(expires, DateTime.utc_now(:second))
+
+  def publicly_readable_remote_post?(_post), do: false
+
+  @doc """
+  The same for a page of them, and the function a **public surface** asks
+  instead of `readable_remote_post_ids/2`: an anonymous reader gets
+  `publicly_readable_remote_post?/1`, a signed-in one the ordinary answer,
+  their own accepted follow included. One call, so a caller serving both never
+  has to hold the difference itself.
+  """
+  def publicly_readable_remote_post_ids(posts, nil) do
+    for post <- posts,
+        publicly_readable_remote_post?(post),
+        into: MapSet.new(),
+        do: post.id
+  end
+
+  def publicly_readable_remote_post_ids(posts, party),
+    do: readable_remote_post_ids(posts, party)
+
   # Claims one slot from the member's hourly like budget. `:ok`, or
   # `{:error, :like_capped}`.
   #

lib/vutuv/fediverse/remote_post.ex

@@ -193,6 +193,16 @@ defmodule Vutuv.Fediverse.RemotePost do
   """
   def open?(%__MODULE__{audience: audience}), do: audience in @open_audiences
 
+  @doc """
+  Whether the author addressed it to the public collection outright — stricter
+  than `open?/1`, which also takes `unlisted` in. The twin of
+  `Vutuv.Fediverse.Note.public?/1`, and the column half of what a page open to
+  everyone may show (`Vutuv.Fediverse.publicly_readable_remote_post?/1` adds the
+  retention half).
+  """
+  def public?(%__MODULE__{audience: "public"}), do: true
+  def public?(%__MODULE__{}), do: false
+
   @doc """
   Whether the author put the post behind a content warning, or marked it
   sensitive. Either one closes the lid: the card shows the warning (or a plain

lib/vutuv/posts.ex

@@ -3713,9 +3713,8 @@ defmodule Vutuv.Posts do
   # answer with nothing to read above it used to be.
   #
   # It rides `remote_reply_ref`, already preloaded with its account
-  # (`post_preloads/0`), so this costs no lookup — only the same three batch
-  # reads a remote card needs anywhere (its pictures, the reader's marks, the
-  # reader's follow), run once for the page. `taken` keeps a post that already
+  # (`post_preloads/0`), so finding one costs no lookup; what it costs beyond
+  # that is `decorate_remote_parents/2` below. `taken` keeps a post that already
   # has a card **further up the feed** from getting a second one; a post whose
   # own row is on *this* page is not in it — that row steps aside instead, see
   # `settle_remote_cards/5`.
@@ -3727,42 +3726,81 @@ defmodule Vutuv.Posts do
           Vutuv.Fediverse.subject_key(parent) not in taken,
           do: %{post_id: post.id, remote_post: parent}
 
-    case Enum.uniq_by(parents, &parent_key/1) do
+    case decorate_remote_parents(parents, viewer) do
+      empty when empty == %{} -> entries
+      by_post -> Enum.map(entries, &claim_remote_parents(&1, by_post))
+    end
+  end
+
+  @doc """
+  The cached post each of these posts answers (issue #1165), as the card the
+  renderer draws above it: `%{post_id => card}`, and `%{}` where none of them
+  answers anything out there.
+
+  What `attach_remote_parents/3` builds for the feed, for a caller holding a
+  plain list of posts instead of feed entries — the permalink's conversation
+  (`VutuvWeb.PostLive.Thread`), which is the page a link to such an answer
+  lands on and was the one place that showed the answer without what it
+  answers.
+  """
+  def remote_parents(posts, viewer) do
+    parents =
+      for post <- posts,
+          %RemotePost{} = parent <- [remote_parent(post)],
+          do: %{post_id: post.id, remote_post: parent}
+
+    decorate_remote_parents(parents, viewer)
+  end
+
+  # The shared tail of both callers: one card per cached post, only the ones
+  # this reader may read, and the batch reads a remote card needs, run once for
+  # the page rather than once per card. Nothing to draw means no read at all.
+  #
+  # **One card per cached post per page**, the rule `dedupe_remote/1`,
+  # `collapse_reposts/1` and `attach_thread_notes/3` already hold for the other
+  # kinds — and here it is not about repetition. The card's action bar is a
+  # LiveComponent keyed by the cached post
+  # (`RemoteActionsComponent.dom_id(:remote_post, id)`), so a second card emits
+  # a duplicate LiveView id, which raises inside `render_pending_components/6`
+  # during the **static** render: the page 500s rather than degrading. Two
+  # members answering the same post out there is ordinary behaviour, and the
+  # first such pair in the database took /feed down for every reader who had
+  # both answers on one page (2026-08-28). So the deduped list decides where
+  # the card renders as well as which reads run: the answers that do not claim
+  # it keep their "Replying to …" line, which is what this feature replaced and
+  # still beats an error page.
+  defp decorate_remote_parents(parents, viewer) do
+    case parents |> Enum.uniq_by(&parent_key/1) |> readable_parents(viewer) do
       [] ->
-        entries
+        %{}
 
       unique ->
-        # **One card per cached post per page**, the rule `dedupe_remote/1`,
-        # `collapse_reposts/1` and `attach_thread_notes/3` already hold for the
-        # other kinds — and here it is not about repetition. The card's action
-        # bar is a LiveComponent keyed by the cached post
-        # (`RemoteActionsComponent.dom_id(:remote_post, id)`), so a second card
-        # emits a duplicate LiveView id, which raises inside
-        # `render_pending_components/6` during the **static** render: the page
-        # 500s rather than degrading. Two members answering the same post out
-        # there is ordinary behaviour, and the first such pair in the database
-        # took /feed down for every reader who had both answers on one page
-        # (2026-08-28).
-        #
-        # `unique` therefore decides where the card renders as well as which
-        # batch reads run, and the placement is built from the decorated list
-        # itself — the older version kept a second list to re-expand from, and
-        # a comment saying the repeats "must not pay for the batch reads, not
-        # the places they render" is exactly how the trap was rationalised.
-        # The answers that do not claim it keep their "Replying to …" line,
-        # which is what this feature replaced and still beats an error page.
-        by_post =
-          unique
-          |> attach_remote_images()
-          |> attach_remote_quotes()
-          |> attach_remote_follows(viewer)
-          |> attach_remote_likes(viewer)
-          |> Map.new(&{&1.post_id, &1})
-
-        Enum.map(entries, &claim_remote_parents(&1, by_post))
+        unique
+        |> attach_remote_images()
+        |> attach_remote_quotes()
+        |> attach_remote_follows(viewer)
+        |> attach_remote_likes(viewer)
+        |> Map.new(&{&1.post_id, &1})
     end
   end
 
+  # Whose audience lets *this* reader see it — never the audience the answer's
+  # author had. Answering a followers-only post in public is refused
+  # (`Fediverse.check_remote_post_reply/2`), but an audience narrows *after* the
+  # answer often enough that the composer re-reads the row for exactly that, and
+  # a card drawn above a public answer would then hand the post to every reader
+  # of that answer. The permalink is a public page, so the question is
+  # `Fediverse.publicly_readable_remote_post_ids/2` rather than the signed-in
+  # one, and an open parent — nearly all of them — costs no query either way.
+  defp readable_parents(parents, viewer) do
+    readable =
+      parents
+      |> Enum.map(& &1.remote_post)
+      |> Vutuv.Fediverse.publicly_readable_remote_post_ids(viewer)
+
+    Enum.filter(parents, &MapSet.member?(readable, &1.remote_post.id))
+  end
+
   defp parent_key(%{remote_post: post}), do: Vutuv.Fediverse.subject_key(post)
 
   defp claim_remote_parents(entry, by_post) do

lib/vutuv_web/agent_docs/markdown.ex

@@ -1180,11 +1180,27 @@ defmodule VutuvWeb.AgentDocs.Markdown do
   defp in_reply_to_line(%{url: nil, author: author}),
     do: "> " <> gettext("In reply to a deleted post by %{name}.", name: author)
 
-  defp in_reply_to_line(%{url: url, author: author}) do
+  defp in_reply_to_line(%{url: url, author: author} = ref) do
     author_link = md_link(author, url)
-    "> " <> gettext("In reply to a post by %{name}.", name: author_link)
+    "> " <> gettext("In reply to a post by %{name}.", name: author_link) <> answered_words(ref)
   end
 
+  # The words of the post answered, when the document carries them — an answer
+  # to another network (issue #1165), whose HTML page draws that post as a card
+  # above the answer. Inside the same blockquote, so it cannot be read as this
+  # post's own body, and escaped as text like every other stranger's writing
+  # here: it must not be able to mint links in our document.
+  defp answered_words(%{content_warning: warning} = ref) when is_binary(warning) do
+    "\n>\n> " <> gettext("Content warning") <> ": " <> md_text(warning) <> answered_text(ref)
+  end
+
+  defp answered_words(ref), do: answered_text(ref)
+
+  defp answered_text(%{text: text}) when is_binary(text) and text != "",
+    do: "\n>\n" <> Enum.map_join(String.split(text, "\n"), "\n", &("> " <> md_text(&1)))
+
+  defp answered_text(_ref), do: ""
+
   defp tags_line([]), do: nil
   defp tags_line(tags), do: "Tags: " <> Enum.map_join(tags, ", ", &"##{&1}")
 

lib/vutuv_web/agent_docs/post_doc.ex

@@ -670,9 +670,27 @@ defmodule VutuvWeb.AgentDocs.PostDoc do
     end
   end
 
+  # `text` is the same words the HTML page draws above the answer as a card, so
+  # it is here under the same gate: our copy of the post, and only while a page
+  # open to everyone may show it (`Fediverse.publicly_readable_remote_post?/1`).
+  # Without it the `.md` sibling of an answer would name the post and withhold
+  # what it says while the page beside it prints both — and the reply written
+  # from out there, four fields further down, has carried its text since #1069.
+  # The handle and the origin URI come off the sidecar either way: they outlive
+  # our copy, which is the whole reason that row keeps them.
   defp remote_in_reply_to(%{remote_reply_ref: %PostRemoteReply{} = ref})
-       when is_binary(ref.handle),
-       do: %{url: ref.in_reply_to_uri, author: ref.handle, network: "fediverse"}
+       when is_binary(ref.handle) do
+    %{url: ref.in_reply_to_uri, author: ref.handle, network: "fediverse"}
+    |> Map.merge(remote_parent_words(ref.remote_post))
+  end
 
   defp remote_in_reply_to(_post), do: nil
+
+  defp remote_parent_words(%RemotePost{} = parent) do
+    if Fediverse.publicly_readable_remote_post?(parent),
+      do: %{text: parent.content_text, content_warning: parent.summary},
+      else: %{}
+  end
+
+  defp remote_parent_words(_parent), do: %{}
 end

lib/vutuv_web/agent_docs/text.ex

@@ -816,8 +816,22 @@ defmodule VutuvWeb.AgentDocs.Text do
   defp in_reply_to_line(%{url: nil, author: author}),
     do: gettext("In reply to a deleted post by %{name}.", name: author)
 
-  defp in_reply_to_line(%{url: url, author: author}),
-    do: gettext("In reply to a post by %{name}.", name: author) <> " #{url}"
+  defp in_reply_to_line(%{url: url, author: author} = ref),
+    do:
+      gettext("In reply to a post by %{name}.", name: author) <> " #{url}" <> answered_words(ref)
+
+  # The words of the post answered, when the document carries them (issue
+  # #1165) — indented under the line naming its author, the way a reply from
+  # another network is indented under its own.
+  defp answered_words(%{content_warning: warning} = ref) when is_binary(warning),
+    do: "\n  " <> gettext("Content warning") <> ": #{warning}" <> answered_text(ref)
+
+  defp answered_words(ref), do: answered_text(ref)
+
+  defp answered_text(%{text: text}) when is_binary(text) and text != "",
+    do: "\n" <> indent_block(text, "  ")
+
+  defp answered_text(_ref), do: ""
 
   defp tags_line([]), do: nil
   defp tags_line(tags), do: "Tags: " <> Enum.join(tags, ", ")

lib/vutuv_web/components/post_components.ex

@@ -965,7 +965,18 @@ defmodule VutuvWeb.PostComponents do
       entry_id: assigns.entry_id
     }
 
-    (ancestors ++ [leaf])
+    assemble_conversation(ancestors ++ [leaf], assigns)
+  end
+
+  # The assembly order of a conversation, for both surfaces that build one: the
+  # reply tree, the "Replying to" banner on whatever ended up a root, the
+  # replies from other networks woven in among the siblings, and the cached post
+  # an answer answers hung above it. Four stages that have to be remembered
+  # together, which is why they are written once — the permalink was missing the
+  # last of them for exactly as long as the two callers each spelled the list
+  # out for themselves.
+  defp assemble_conversation(cards, assigns) do
+    cards
     |> Posts.thread_forest()
     |> banner_on_roots()
     |> weave_remote_replies(
@@ -3292,6 +3303,13 @@ defmodule VutuvWeb.PostComponents do
         "one card, never the replies around it"
   )
 
+  attr(:remote_parents, :map,
+    default: %{},
+    doc:
+      "`%{post_id => card}` (`Vutuv.Posts.remote_parents/2`) for a post here " <>
+        "that answers one out there (issue #1165) — drawn above it, the way the feed draws it"
+  )
+
   attr(:conn_or_socket, :any, required: true)
   attr(:translations, :map, default: nil)
 
@@ -3329,6 +3347,7 @@ defmodule VutuvWeb.PostComponents do
   attr(:remote_replies, :map, default: %{})
   attr(:note_marks, :any, default: nil)
   attr(:likers, :any, default: nil)
+  attr(:remote_parents, :map, default: %{}, doc: "as on `thread_conversation/1`")
   attr(:conn_or_socket, :any, required: true)
   attr(:translations, :map, default: nil)
 
@@ -3407,6 +3426,12 @@ defmodule VutuvWeb.PostComponents do
   # is the first card on the page, the one case where the focused post has no
   # context above it and the page must not jump on arrival.
   defp conversation_nodes(posts, top_id, assigns) do
+    # A post with the card it answers drawn above it is no longer the page's
+    # first card, so the focus scrolls into view like any other post with
+    # context over it. Decided once, here, rather than as a second condition
+    # every card then evaluates.
+    top_id = if is_map_key(assigns.remote_parents, top_id), do: nil, else: top_id
+
     posts
     |> Enum.map(fn post ->
       focus? = post.id == assigns.focus_id
@@ -3427,13 +3452,7 @@ defmodule VutuvWeb.PostComponents do
         scroll?: assigns.auto_scroll? and focus? and post.id != top_id
       }
     end)
-    |> Posts.thread_forest()
-    |> banner_on_roots()
-    |> weave_remote_replies(
-      assigns[:remote_replies] || %{},
-      assigns.viewer,
-      assigns[:note_marks] || fn _note -> nil end
-    )
+    |> assemble_conversation(assigns)
   end
 
   # Hangs the replies written on other networks (issue #1069) under the posts