feat: FC authors the post that Discord never wrote (milestone 388 step E2)

Discord is a delivery channel, not a publisher. One message is not one post,
and today every message lands as its own `post` row, so chat lines compete
with authored work for the same surface. Rather than demote them into a
second-class feed, FC now writes the post itself: one row per DROP, its
images the drop's images, its body the messages' text in arrival order.

Synthesising a `Post` (rather than inventing a parallel entity) is the whole
point — the result is post-shaped by construction, so feed, provenance,
translation, attachments and series keep working on it unchanged.

The predicate is three axes ANDed, and the time one does the real work:

    same source  AND  cosine distance <= threshold  AND  no gap > window

Similarity alone over-groups, and that is the failure that would make this
useless: any two pieces of the same character by the same artist sit close in
SigLIP space, so a cosine-only rule collapses a month of one character into a
single "post". Two details inside the predicate are load-bearing —

* distance is measured to the group's SEED, never to the previous member,
  because chaining lets a group DRIFT: twenty small steps walk from one piece
  to a completely different one, each hop individually within threshold;
* the window is measured between CONSECUTIVE messages, not from the first, so
  an artist trickling variants out over an evening stays one drop.

Why a post-import sweep and not part of ingest. The obvious alternative was to
migrate Discord to the native post-first ingester (#1266) and group at capture
time. That cannot work: the grouping signal is `siglip_embedding`, which is
produced asynchronously AFTER import (tasks/ml.py, the GPU backfill), so at
capture time there is nothing to group on. Grouping is necessarily something
that happens once the vectors catch up — hence a re-runnable sweep that skips
what it cannot yet place, and an hourly (not daily) cadence.

The honesty rule, enforced in the schema. `post.synthesized_by` names the
grouper; `synthesis_details` records the members, the count, and the
thresholds AS THEY WERE (they are operator-tunable, so without that "why did
it group these" is unanswerable a month later). Member posts are absorbed, not
destroyed — they remain the images' true origin and the audit trail — and
`absorbed_by_post_id` is ON DELETE SET NULL, so deleting a synthetic post
releases its members back into the feed in one DELETE with no repair step.
`post_title` stays NULL deliberately: a synthesised title is the one place
this could put words in a creator's mouth.

Two guards the first draft would have failed:

* the per-run cap took the lowest post IDs, not the oldest posts — DISTINCT ON
  forces its own ORDER BY, so the sort now happens outside the subquery;
* a cap landing mid-drop would have published a truncated group claiming to be
  a whole drop, so the last group is left for the next run.

And one vacuous test caught before it shipped: the support vector perturbed a
single component of an all-ones vector, moving it ~1e-6, so every distance
assertion passed regardless of what the predicate did. `_vec` now builds a
unit vector at a stated angle, where distance is exactly 1 - cos(delta) —
rule 167, a guard has to be able to fail.

UI (rule 27) follows in the next commit.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNXXULQDjVZmbuNa2G9mD9

backend/app/services/post_feed_service.py

@@ -86,6 +86,13 @@ class PostFeedService:
             .join(Artist, Post.artist_id == Artist.id)
             .outerjoin(Source, Post.source_id == Source.id)
         )
+        # Absorbed posts are the individual chat messages a synthetic post
+        # replaced (milestone 388 E2). They stay in the table — they are the
+        # images' true origin and the grouping has to be auditable — but the
+        # feed shows the post FC authored, not the dozen lines it was built
+        # from. `around` and `get_post` deliberately do NOT apply this: reaching
+        # a member by id is how you inspect a grouping.
+        stmt = stmt.where(Post.absorbed_by_post_id.is_(None))
         if artist_id is not None:
             stmt = stmt.where(Post.artist_id == artist_id)
         if platform is not None:
@@ -400,6 +407,18 @@ class PostFeedService:
             "translated_source_lang": post.translated_source_lang,
             # Sticky per-post translation choice (auto/force/original, #155).
             "translation_override": post.translation_override,
+            # Milestone 388 E2. Non-null means FC AUTHORED this post by grouping
+            # a creator's drop — the UI must say so wherever the post appears,
+            # and `synthesis` carries what it was built from so the operator can
+            # audit a grouping FC invented. Null for every real post; the two
+            # keys are always present so the frontend never branches on absence.
+            "synthesized_by": post.synthesized_by,
+            "synthesis": post.synthesis_details,
+            # Non-null on a chat message a synthetic post absorbed. The feed
+            # filters these out, but `around`/`get_post` still reach them, and
+            # the UI uses this to explain why a post it linked to is not in the
+            # stream.
+            "absorbed_by_post_id": post.absorbed_by_post_id,
             "artist": {"id": artist.id, "name": artist.name, "slug": artist.slug},
             "source": (
                 {"id": source.id, "platform": source.platform}