polish(editor): clarify feed title/url vs. organizers in feed settings

feed.title/feed.url name who PUBLISHES the feed; feed.organizers names who
ORGANIZES the events in it — distinct per the OTE v0.3 spec, but for the
common case (one community publishing its own events) the two end up
holding near-identical values, reading as pointless duplication rather
than the intentional distinction it is.

Feed settings now splits into two headed groups: "About this feed"
(title/description/url) and "Defaults for your events" (license,
textLanguage, organizers), the latter carrying one shared note explaining
the replace-not-merge inheritance pattern all three follow — instead of
three fields with no framing and, previously, no visible relationship to
each other.

Organizers specifically gets three more pieces, DOM-inserted after
renderRepeaterField's own label (same "patch the mounted subtree"
technique already used this session to fix that field's info-tooltip
copy, since REPEATER_SPECS.organizers is shared with the event form's own
organizers field and can't carry feed-specific text):
- A plain-language note adapted from the spec's own wording distinguishing
  the two fields.
- "Use the same details as above" — visible only while organizers is
  empty, appends one row prefilled from Title/URL, left fully editable.
- An aggregator warning, shown when lib/feed-config.ts's new
  likelyAggregatorFeed(events) detects 3+ distinct organizer sets among
  events that declare their own (computed from the already-loaded event
  list when the view opens) — explaining that the spec requires leaving
  the field empty in that case, since filling it would misattribute every
  aggregated event to whoever runs the feed. Deliberately conservative:
  a single co-organized "guest" event alongside a one-community feed — the
  normal case the spec documents — produces exactly 2 distinct sets, not
  3, so it never fires on that.

v1 scope is automatic detection only, no manual "this is an aggregator"
toggle — not a real ote.config.json field, so nothing to save it into.

Also extracted #warnings' banner styling into a reusable .warning-box
class for the new organizers warning, rather than duplicating it.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DrGeVXHTNNdPi7MCgSageG

Author: hhkaos

apps/editor/index.html

@@ -178,6 +178,8 @@ <h2 data-i18n="dialog.feedSettings.title">Feed settings</h2>
           Edits ote.config.json's feed block — the profile and other editor
           settings in that file aren't touched.
         </p>
+
+        <h3 data-i18n="dialog.feedSettings.aboutGroup">About this feed</h3>
         <div class="field">
           <label for="feed-title" data-i18n="dialog.feedSettings.titleLabel">Title</label>
           <input id="feed-title" type="text" />
@@ -192,6 +194,13 @@ <h2 data-i18n="dialog.feedSettings.title">Feed settings</h2>
           <label for="feed-url" data-i18n="dialog.feedSettings.urlLabel">URL</label>
           <input id="feed-url" type="url" />
         </div>
+
+        <h3 data-i18n="dialog.feedSettings.defaultsGroup">Defaults for your events</h3>
+        <p class="hint" data-i18n="dialog.feedSettings.defaultsGroupNote">
+          Every event inherits these unless it declares its own — an event
+          that does replaces the value entirely, it's never merged with
+          what's set here.
+        </p>
         <div class="field pair">
           <div>
             <label for="feed-license" data-i18n="dialog.feedSettings.licenseLabel">License</label>

apps/editor/src/i18n/es.ts

@@ -46,6 +46,10 @@ export const es: Record<string, string> = {
   "dialog.feedSettings.title": "Configuración del feed",
   "dialog.feedSettings.hint":
     "Edita el bloque feed de ote.config.json — el perfil y otros ajustes del editor en ese fichero no se tocan.",
+  "dialog.feedSettings.aboutGroup": "Sobre este feed",
+  "dialog.feedSettings.defaultsGroup": "Valores por defecto para tus eventos",
+  "dialog.feedSettings.defaultsGroupNote":
+    "Todo evento hereda estos valores salvo que declare el suyo propio — y si lo declara, lo sustituye por completo, nunca se combina con lo que hay aquí.",
   "dialog.feedSettings.titleLabel": "Título",
   "dialog.feedSettings.descriptionLabel": "Descripción",
   "dialog.feedSettings.urlLabel": "URL",
@@ -65,6 +69,11 @@ export const es: Record<string, string> = {
     "El idioma en el que están escritos el título/descripción de tu feed (y el nombre/descripción de tus eventos). Solo hace falta si usas traducciones.",
   "dialog.feedSettings.organizersInfo":
     "Quién organiza tu comunidad, por defecto. Cada evento hereda esta lista salvo que declare sus propios organizadores, que entonces la REEMPLAZAN, no se combinan con ella.",
+  "dialog.feedSettings.organizersNote":
+    "El título/URL de arriba dicen quién publica este feed; organizers, quién organiza los eventos que contiene. Si este feed solo publica tus propios eventos, probablemente coincidan. Solo son distintos si agregas eventos de otras comunidades — en ese caso, deja este campo vacío (ver aviso abajo).",
+  "dialog.feedSettings.organizersQuickFill": "Usar los mismos datos que arriba",
+  "dialog.feedSettings.organizersAggregatorWarning":
+    "Aviso: los eventos de este feed declaran organizadores bastante distintos entre sí. Si este feed agrega eventos de otras comunidades, deja este campo vacío — la spec lo exige: rellenarlo atribuiría cada evento agregado a quien lleva este feed, no a quien realmente lo organiza.",
   "dialog.review.title": "Revisar y enviar",
   "dialog.review.hintRepo":
     "Esto abre un issue de GitHub prerrellenado en el repositorio de destino; una persona mantenedora (o la automatización del repositorio) lo convierte en un pull request.",

apps/editor/src/lib/feed-config.ts

@@ -1,5 +1,5 @@
 import { cleanRow, isRowEmpty } from "./event-json.js";
-import type { OrganizerRow, OteConfig } from "./types.js";
+import type { OrganizerRow, OteConfig, OteEvent } from "./types.js";
 
 /**
  * Flat, all-string form model for ote.config.json's `feed` block — same
@@ -102,3 +102,23 @@ export function toOteConfigJson(
 
   return { ...(rawConfig ?? {}), feed };
 }
+
+/**
+ * True when 3+ distinct organizer sets appear among events that declare
+ * their own `organizers` — the spec's own signal that a feed is (or is
+ * becoming) an aggregator, where `feed.organizers` must stay empty (filling
+ * it would misattribute every event to whoever runs the feed, not who
+ * actually organizes each one). Deliberately conservative: a single
+ * co-organized event alongside a one-community feed — the normal case the
+ * spec itself documents (repeat the feed's own community plus the guest) —
+ * produces exactly 2 distinct sets (the feed's own + the one guest event's),
+ * not 3; this never fires on that case.
+ */
+export function likelyAggregatorFeed(events: readonly OteEvent[]): boolean {
+  const signatures = new Set<string>();
+  for (const event of events) {
+    if (!event.organizers || event.organizers.length === 0) continue;
+    signatures.add([...event.organizers].map((o) => o.name).sort().join("|"));
+  }
+  return signatures.size >= 3;
+}

apps/editor/src/main.ts

@@ -36,6 +36,7 @@ import {
 import {
   emptyFeedConfigState,
   fromOteConfig,
+  likelyAggregatorFeed,
   toOteConfigJson,
 } from "./lib/feed-config.js";
 import {
@@ -408,14 +409,39 @@ async function startEditor(repo: string | null): Promise<void> {
     }
 
     let feedState = emptyFeedConfigState();
+    // Computed once per open (from the already-loaded event list, no new
+    // fetch) — see the feedSettingsOpen handler below.
+    let aggregatorLikely = false;
 
     function renderFeedOrganizers(): void {
       feedOrganizersSlot.textContent = "";
+
+      // "Use the same details as above" — visible only while organizers is
+      // still empty; appends one row prefilled from Title/URL, left fully
+      // editable. Declared before renderRepeaterField so its onArrayChange
+      // callback can toggle this button's visibility without a full rebuild.
+      const quickFillBtn = document.createElement("button");
+      quickFillBtn.type = "button";
+      quickFillBtn.className = "secondary organizers-quick-fill";
+      quickFillBtn.textContent = t(
+        "dialog.feedSettings.organizersQuickFill",
+        "Use the same details as above",
+      );
+      quickFillBtn.hidden = feedState.organizers.length > 0;
+      quickFillBtn.addEventListener("click", () => {
+        feedState.organizers = [
+          ...feedState.organizers,
+          { name: feedState.title, url: feedState.url, email: "", type: "" },
+        ];
+        renderFeedOrganizers(); // deliberate, infrequent action — a full rebuild here is fine
+      });
+
       const rendered = renderRepeaterField(
         "organizers",
         feedState.organizers as unknown as Record<string, string>[],
         (_key, items) => {
           feedState.organizers = items as unknown as OrganizerRow[];
+          quickFillBtn.hidden = feedState.organizers.length > 0;
         },
         () => "",
       );
@@ -430,6 +456,37 @@ async function startEditor(repo: string | null): Promise<void> {
           "Who runs your community, by default. Every event inherits this list unless it declares its own organizers, which then REPLACES it, not merges.",
         );
       }
+
+      // title/url above name who PUBLISHES the feed; this field is who
+      // ORGANIZES the events in it — the same distinction REPEATER_SPECS'
+      // own info text can't carry without leaking feed-specific wording
+      // into the event form that reuses it, so it's a separate note here.
+      const note = document.createElement("p");
+      note.className = "hint organizers-feed-note";
+      note.textContent = t(
+        "dialog.feedSettings.organizersNote",
+        "Title/URL above name who publishes this feed; organizers is who organizes the events in it. If this feed only publishes your own events, they probably match. They only differ once you aggregate events from other communities — leave this empty in that case (see the notice below).",
+      );
+
+      const label = rendered.querySelector("label");
+      if (label) {
+        // Inserted in reverse of the desired final order — each .after()
+        // on the same reference node pushes the previous insertion down.
+        label.after(quickFillBtn);
+        if (aggregatorLikely) {
+          const warning = document.createElement("div");
+          warning.className = "warning-box organizers-warning";
+          const p = document.createElement("p");
+          p.textContent = t(
+            "dialog.feedSettings.organizersAggregatorWarning",
+            "Heads up: the events in this feed declare noticeably different organizers. If this feed aggregates events from other communities, leave this field empty — the spec requires it: filling it would attribute every aggregated event to whoever runs this feed, not who actually organizes each one.",
+          );
+          warning.append(p);
+          label.after(warning);
+        }
+        label.after(note);
+      }
+
       feedOrganizersSlot.append(rendered);
     }
 
@@ -449,6 +506,7 @@ async function startEditor(repo: string | null): Promise<void> {
 
     feedSettingsOpen.addEventListener("click", () => {
       feedState = fromOteConfig(config);
+      aggregatorLikely = likelyAggregatorFeed(listed.map((entry) => entry.event));
       feedTitleInput.value = feedState.title;
       feedDescriptionInput.value = feedState.description;
       feedUrlInput.value = feedState.url;

apps/editor/styles.css

@@ -96,7 +96,8 @@ header h1 {
 
 /* --- warnings ------------------------------------------------------------ */
 
-#warnings {
+#warnings,
+.warning-box {
   background: #fff8e1;
   border: 1px solid #e6c65c;
   border-radius: var(--radius);
@@ -105,7 +106,8 @@ header h1 {
   font-size: 0.9rem;
 }
 
-#warnings p {
+#warnings p,
+.warning-box p {
   margin: 0.2rem 0;
 }
 
@@ -1654,6 +1656,38 @@ footer {
   font-size: 1.2rem;
 }
 
+#feed-settings-view h3 {
+  margin: 1.5rem 0 0.25rem;
+  padding-top: 1.25rem;
+  border-top: 1px solid var(--border);
+  font-size: 0.95rem;
+  font-weight: 600;
+}
+
+#feed-settings-view h3:first-of-type {
+  margin-top: 1rem;
+  padding-top: 0;
+  border-top: none;
+}
+
+#feed-settings-view h3 + .hint {
+  margin-bottom: 1rem;
+}
+
+/* Note/warning/quick-fill inserted after the (reused, event-form) organizers
+   repeater's own label — see main.ts's renderFeedOrganizers. */
+.organizers-feed-note {
+  margin: 0.3rem 0 0.75rem;
+}
+
+.organizers-quick-fill {
+  margin-bottom: 0.75rem;
+}
+
+.warning-box.organizers-warning {
+  margin: 0.5rem 0 0.75rem;
+}
+
 #feed-settings-view .actions {
   margin-top: 1.25rem;
 }

apps/editor/test/feed-config.test.ts

@@ -3,9 +3,10 @@ import { describe, expect, it } from "vitest";
 import {
   emptyFeedConfigState,
   fromOteConfig,
+  likelyAggregatorFeed,
   toOteConfigJson,
 } from "../src/lib/feed-config.js";
-import type { OteConfig } from "../src/lib/types.js";
+import type { OteConfig, OteEvent } from "../src/lib/types.js";
 
 // Shaped after OpenTechEvents/ote-template's real ote.config.json (checked
 // via the GitHub API while planning this feature): top-level `_comment*`
@@ -145,3 +146,64 @@ describe("toOteConfigJson", () => {
     expect(feed.organizers).toBeUndefined();
   });
 });
+
+describe("likelyAggregatorFeed", () => {
+  const eventWithOrganizers = (id: string, names: string[]): OteEvent =>
+    ({
+      id,
+      name: id,
+      timezone: "Europe/Madrid",
+      startDate: "2026-06-11T18:30",
+      organizers: names.map((name) => ({ name })),
+    }) as unknown as OteEvent;
+
+  it("no events → false", () => {
+    expect(likelyAggregatorFeed([])).toBe(false);
+  });
+
+  it("events with no organizers of their own → false", () => {
+    const events = [
+      { id: "a", name: "a", timezone: "Europe/Madrid", startDate: "2026-06-11T18:30" },
+      { id: "b", name: "b", timezone: "Europe/Madrid", startDate: "2026-07-11T18:30" },
+    ] as unknown as OteEvent[];
+    expect(likelyAggregatorFeed(events)).toBe(false);
+  });
+
+  it("every event sharing the same organizer set → false", () => {
+    const events = [
+      eventWithOrganizers("a", ["PyAlmería"]),
+      eventWithOrganizers("b", ["PyAlmería"]),
+      eventWithOrganizers("c", ["PyAlmería"]),
+    ];
+    expect(likelyAggregatorFeed(events)).toBe(false);
+  });
+
+  it("one community feed plus a single co-organized guest event (2 sets) → false, the normal case", () => {
+    const events = [
+      eventWithOrganizers("a", ["PyAlmería"]),
+      eventWithOrganizers("b", ["PyAlmería"]),
+      // The one co-organized event: the community plus a guest.
+      eventWithOrganizers("c", ["PyAlmería", "Django Girls Almería"]),
+    ];
+    expect(likelyAggregatorFeed(events)).toBe(false);
+  });
+
+  it("3+ genuinely distinct organizer sets → true", () => {
+    const events = [
+      eventWithOrganizers("a", ["PyAlmería"]),
+      eventWithOrganizers("b", ["GDG Madrid"]),
+      eventWithOrganizers("c", ["React Barcelona"]),
+    ];
+    expect(likelyAggregatorFeed(events)).toBe(true);
+  });
+
+  it("organizer order within an event doesn't create a false distinct set", () => {
+    const events = [
+      eventWithOrganizers("a", ["Alice", "Bob"]),
+      eventWithOrganizers("b", ["Bob", "Alice"]),
+      eventWithOrganizers("c", ["Carol"]),
+    ];
+    // Only 2 distinct sets ({Alice,Bob} and {Carol}) once order is ignored.
+    expect(likelyAggregatorFeed(events)).toBe(false);
+  });
+});