From 02768ce5f59bbaa57807dc244defbe3df5d2addf Mon Sep 17 00:00:00 2001
From: ssavutu <ssavutu@gmail.com>
Date: Thu, 3 Sep 2026 06:10:54 -0400
Subject: [PATCH] Raise the breaking-news banner from the article that is
 breaking

Any editor could already tick "Breaking news" on their article, and the
flag did nothing: it was stored, returned by the API, and read by no one.
The banner it should have driven was a separate admin-only setting with
hand-typed text, so raising one meant messaging an admin and having them
retype the headline.

Wire the flag to the banner, and derive the banner rather than storing a
second copy of the decision. GetBreakingNewsState resolves it on read from
the newest published article flagged breaking, falling back to the manual
banner when there is none.

Deriving it is what makes scheduling work. The published predicate is the
same one every other public read uses, so a story scheduled for 11am
starts driving the banner at the instant it starts being readable -- there
is no publish hook that could fire early, late, or not at all, and
unticking the flag takes the banner down just as directly. The public
cache is 60s and the scheduler ticks at 60s, so the banner lands within a
tick of the story.

An article wins over the manual banner: it is the more specific and more
recent signal, and "this story is the breaking story now" is the flow the
flag exists for. The manual banner is kept separate in the API response so
Settings can still edit it while an article overrides it -- binding the
form to the effective value would overwrite an admin's text with a
headline on their next save.

The banner carries the article's slug, not a path: the public site owns
its URL shape and already composes links this way for developing stories.

Admins can also set a limit after which a flagged article stops holding
the homepage. It is off by default, so nothing takes a banner down on an
editor's behalf unless someone asked for that.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ES8gPZxe6sb5xSLrBZ7AGk
---
 frontend/src/pages/editArticleView.tsx        |   8 +-
 frontend/src/pages/settingsPage.tsx           | 152 ++++++++--
 server/docs/docs.go                           |  22 ++
 server/docs/swagger.json                      |  22 ++
 server/docs/swagger.yaml                      |  17 ++
 .../breaking_news_integration_test.go         | 272 ++++++++++++++++++
 .../internal/database/breaking_news_test.go   |  27 ++
 server/internal/database/settings.go          | 151 +++++++++-
 server/internal/database/users.go             |  19 ++
 ...breaking_news_settings_integration_test.go | 178 ++++++++++++
 server/internal/handlers/settings.go          |  44 ++-
 server/internal/models/api_responses.go       |  52 +++-
 server/main.go                                |   3 +
 13 files changed, 928 insertions(+), 39 deletions(-)
 create mode 100644 server/internal/database/breaking_news_integration_test.go
 create mode 100644 server/internal/database/breaking_news_test.go
 create mode 100644 server/internal/handlers/breaking_news_settings_integration_test.go

diff --git a/frontend/src/pages/editArticleView.tsx b/frontend/src/pages/editArticleView.tsx
index 3ffd6f3..7234fa9 100644
--- a/frontend/src/pages/editArticleView.tsx
+++ b/frontend/src/pages/editArticleView.tsx
@@ -1545,7 +1545,13 @@ function EditArticleView() {
                 onChange={(e) => setBreakingNews(e.target.checked)}
                 type="checkbox"
               />
-              <span className="font-medium text-foreground">Breaking news</span>
+              <span className="flex flex-col gap-0.5">
+                <span className="font-medium text-foreground">Breaking news</span>
+                <span className="text-[11px] text-muted-foreground">
+                  Raises the red banner across the top of the homepage, with this headline, from the moment the article
+                  publishes -- scheduled stories included. Untick it to take the banner down.
+                </span>
+              </span>
             </label>
 
             <label className="flex items-start gap-3 rounded-lg border border-border bg-background px-3 py-3 text-sm">
diff --git a/frontend/src/pages/settingsPage.tsx b/frontend/src/pages/settingsPage.tsx
index 2eb5e2a..764cf31 100644
--- a/frontend/src/pages/settingsPage.tsx
+++ b/frontend/src/pages/settingsPage.tsx
@@ -5,7 +5,7 @@ import MediaPicker, { type MediaPickerItem } from "../components/MediaPicker"
 import SettingsSection from "../components/SettingsSection"
 import { useApiFetch } from "../hooks/useApiFetch"
 import { useCurrentUserRole } from "../hooks/useCurrentUserRole"
-import { useNavigate } from "react-router-dom"
+import { Link, useNavigate } from "react-router-dom"
 import { useSessionAuth } from "../auth/sessionAuthContext"
 
 type IndexStatus = {
@@ -36,6 +36,45 @@ const emptyCarouselSlide = (): CarouselSlide => ({
   desktop_only: false,
 })
 
+// Mirrors server/internal/database/settings.go; the API clamps anything larger.
+const MAX_BREAKING_WINDOW_HOURS = 24 * 7
+
+type BreakingNewsResponse = {
+  enabled?: boolean
+  text?: string
+  source?: string
+  article_slug?: string
+  article_title?: string
+  manual?: { enabled?: boolean; text?: string }
+  window_hours?: number
+}
+
+type BreakingNewsLive = {
+  source: string
+  text: string
+  articleSlug?: string
+}
+
+// The endpoint returns the RESOLVED banner at the top level and the hand-typed
+// one under `manual`. The form edits the manual banner, so it has to read from
+// `manual` -- binding it to the top level would silently overwrite the manual
+// text with an article's headline the next time an admin hit save.
+function readBreakingNews(body: BreakingNewsResponse) {
+  return {
+    manual: {
+      enabled: Boolean(body.manual?.enabled),
+      text: String(body.manual?.text ?? ""),
+    },
+    live: {
+      source: String(body.source ?? "none"),
+      text: String(body.text ?? ""),
+      articleSlug: body.article_slug,
+    } satisfies BreakingNewsLive,
+    // 0 means the banner has no time limit, which is the default.
+    window: String(body.window_hours ?? 0),
+  }
+}
+
 function Field({ label, children }: { label: string; children: React.ReactNode }) {
   return (
     <div className="flex flex-col gap-1.5">
@@ -72,9 +111,18 @@ export default function SettingsPage() {
   const [taxonomyRebuildMessage, setTaxonomyRebuildMessage] = useState<string | null>(null)
   const [breakingEnabled, setBreakingEnabled] = useState(false)
   const [breakingText, setBreakingText] = useState("")
-  const [breakingSaved, setBreakingSaved] = useState<{ enabled: boolean; text: string }>({ enabled: false, text: "" })
+  const [breakingWindowOn, setBreakingWindowOn] = useState(false)
+  const [breakingWindow, setBreakingWindow] = useState("24")
+  const [breakingSaved, setBreakingSaved] = useState<{ enabled: boolean; text: string; window: string }>({
+    enabled: false,
+    text: "",
+    window: "0",
+  })
   const [breakingSaving, setBreakingSaving] = useState(false)
   const [breakingMessage, setBreakingMessage] = useState<string | null>(null)
+  // What the public site is actually showing, which is not always what the
+  // fields below hold: a published article flagged breaking overrides them.
+  const [breakingLive, setBreakingLive] = useState<BreakingNewsLive>({ source: "none", text: "" })
   const [carouselSlides, setCarouselSlides] = useState<CarouselSlide[]>([])
   const [carouselSaved, setCarouselSaved] = useState<CarouselSlide[]>([])
   const [carouselSaving, setCarouselSaving] = useState(false)
@@ -116,13 +164,15 @@ export default function SettingsPage() {
       try {
         const res = await apiFetch("/v1/settings/breaking-news")
         if (!res.ok) throw new Error(await readErrorMessage(res, `Could not load breaking news settings (${res.status})`))
-        const body = (await res.json()) as { enabled?: boolean; text?: string }
-        const enabled = Boolean(body.enabled)
-        const text = String(body.text ?? "")
+        const body = (await res.json()) as BreakingNewsResponse
+        const state = readBreakingNews(body)
         if (!cancelled) {
-          setBreakingEnabled(enabled)
-          setBreakingText(text)
-          setBreakingSaved({ enabled, text })
+          setBreakingEnabled(state.manual.enabled)
+          setBreakingText(state.manual.text)
+          setBreakingWindowOn(state.window !== "0")
+          setBreakingWindow(state.window === "0" ? "24" : state.window)
+          setBreakingSaved({ enabled: state.manual.enabled, text: state.manual.text, window: state.window })
+          setBreakingLive(state.live)
         }
       } catch (err) {
         if (!cancelled) {
@@ -166,6 +216,15 @@ export default function SettingsPage() {
       setBreakingMessage("Banner text is required when the banner is enabled")
       return
     }
+    // 0 is what the API takes for "no limit", which is the unticked state.
+    const windowHours = breakingWindowOn ? Number(breakingWindow) : 0
+    if (
+      breakingWindowOn &&
+      (!Number.isInteger(windowHours) || windowHours < 1 || windowHours > MAX_BREAKING_WINDOW_HOURS)
+    ) {
+      setBreakingMessage(`Banner duration must be a whole number of hours between 1 and ${MAX_BREAKING_WINDOW_HOURS}`)
+      return
+    }
 
     setBreakingSaving(true)
     setBreakingMessage(null)
@@ -173,15 +232,17 @@ export default function SettingsPage() {
       const res = await apiFetch("/v1/settings/breaking-news", {
         method: "PATCH",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ enabled: breakingEnabled, text }),
+        body: JSON.stringify({ enabled: breakingEnabled, text, window_hours: windowHours }),
       })
       if (!res.ok) throw new Error(await readErrorMessage(res, `Could not save breaking news settings (${res.status})`))
-      const body = (await res.json()) as { enabled?: boolean; text?: string }
-      const savedEnabled = Boolean(body.enabled)
-      const savedText = String(body.text ?? "")
-      setBreakingEnabled(savedEnabled)
-      setBreakingText(savedText)
-      setBreakingSaved({ enabled: savedEnabled, text: savedText })
+      const body = (await res.json()) as BreakingNewsResponse
+      const state = readBreakingNews(body)
+      setBreakingEnabled(state.manual.enabled)
+      setBreakingText(state.manual.text)
+      setBreakingWindowOn(state.window !== "0")
+      setBreakingWindow(state.window === "0" ? "24" : state.window)
+      setBreakingSaved({ enabled: state.manual.enabled, text: state.manual.text, window: state.window })
+      setBreakingLive(state.live)
       setBreakingMessage("Saved")
     } catch (err) {
       setBreakingMessage(err instanceof Error ? err.message : "Could not save breaking news settings.")
@@ -366,7 +427,11 @@ export default function SettingsPage() {
 
   const carouselDirty = JSON.stringify(carouselSlides) !== JSON.stringify(carouselSaved)
   const siteTitleDirty = siteTitleDraft.trim() !== siteTitle
-  const breakingDirty = breakingEnabled !== breakingSaved.enabled || breakingText.trim() !== breakingSaved.text
+  const breakingWindowValue = breakingWindowOn ? breakingWindow.trim() : "0"
+  const breakingDirty =
+    breakingEnabled !== breakingSaved.enabled ||
+    breakingText.trim() !== breakingSaved.text ||
+    breakingWindowValue !== breakingSaved.window
 
   return (
     <div className="flex flex-col gap-6 p-6">
@@ -628,9 +693,28 @@ export default function SettingsPage() {
         title="Breaking News"
         storageKey="breaking-news"
         dirty={breakingDirty}
-        summary={breakingEnabled ? "Enabled" : "Off"}
-        description="Show a breaking-news banner across the top of the public homepage."
+        summary={
+          breakingLive.source === "article" ? "Live from an article" : breakingLive.source === "manual" ? "Enabled" : "Off"
+        }
+        description="Show a breaking-news banner across the top of the public homepage. Any editor can raise one by ticking Breaking news on their article; it appears when the article publishes and comes down when the flag does."
       >
+        {breakingLive.source === "article" && (
+          <div className="rounded-lg border border-border bg-muted/40 px-3 py-2 text-sm text-foreground">
+            <span className="font-medium">An article is driving the banner:</span> &ldquo;{breakingLive.text}&rdquo;
+            <div className="mt-1 text-xs text-muted-foreground">
+              It overrides the banner below until it is unflagged or its duration runs out. To take it down now, untick
+              &ldquo;Breaking news&rdquo; on{" "}
+              {breakingLive.articleSlug ? (
+                <Link to={`/articles/${encodeURIComponent(breakingLive.articleSlug)}/edit`} className="underline">
+                  that article
+                </Link>
+              ) : (
+                "that article"
+              )}
+              .
+            </div>
+          </div>
+        )}
         <label className="flex items-center gap-3 cursor-pointer select-none">
           <input
             type="checkbox"
@@ -649,14 +733,40 @@ export default function SettingsPage() {
             placeholder="Breaking news headline"
           />
         </div>
+        <div className="flex flex-col gap-2 max-w-xl">
+          <label className="flex items-center gap-3 cursor-pointer select-none">
+            <input
+              type="checkbox"
+              checked={breakingWindowOn}
+              onChange={(e) => setBreakingWindowOn(e.target.checked)}
+              className="h-4 w-4 rounded border-border text-primary focus:ring-2 focus:ring-primary/40"
+            />
+            <span className="text-sm text-foreground">Take article banners down automatically</span>
+          </label>
+          {breakingWindowOn && (
+            <div className="flex items-center gap-2 pl-7">
+              <input
+                type="number"
+                min={1}
+                max={MAX_BREAKING_WINDOW_HOURS}
+                value={breakingWindow}
+                onChange={(e) => setBreakingWindow(e.target.value)}
+                className="w-24 px-3 py-2 rounded-lg border border-border bg-background text-sm focus:outline-none focus:ring-2 focus:ring-primary/40"
+              />
+              <span className="text-sm text-muted-foreground">hours after the article publishes</span>
+            </div>
+          )}
+          <span className="text-xs text-muted-foreground pl-7">
+            Off by default: a banner raised from an article stays up until an editor unticks &ldquo;Breaking news&rdquo;
+            on it. Does not affect the banner above.
+          </span>
+        </div>
         <div className="flex items-center gap-3">
           <button
             type="button"
             onClick={saveBreakingNews}
             disabled={
-              breakingSaving ||
-              (breakingEnabled && breakingText.trim() === "") ||
-              (breakingEnabled === breakingSaved.enabled && breakingText.trim() === breakingSaved.text)
+              breakingSaving || (breakingEnabled && breakingText.trim() === "") || !breakingDirty
             }
             className="inline-flex items-center gap-2 px-4 py-2 rounded-lg bg-primary text-primary-foreground text-sm font-medium hover:bg-primary/90 disabled:opacity-60"
           >
diff --git a/server/docs/docs.go b/server/docs/docs.go
index abf6f4e..be5b0cc 100644
--- a/server/docs/docs.go
+++ b/server/docs/docs.go
@@ -4984,6 +4984,9 @@ const docTemplate = `{
         "models.BreakingNewsSettings": {
             "type": "object",
             "properties": {
+                "article_slug": {
+                    "type": "string"
+                },
                 "enabled": {
                     "type": "boolean"
                 },
@@ -5000,17 +5003,36 @@ const docTemplate = `{
                 },
                 "text": {
                     "type": "string"
+                },
+                "window_hours": {
+                    "type": "integer"
                 }
             }
         },
         "models.BreakingNewsSettingsResponse": {
             "type": "object",
             "properties": {
+                "article_slug": {
+                    "type": "string"
+                },
+                "article_title": {
+                    "type": "string"
+                },
                 "enabled": {
                     "type": "boolean"
                 },
+                "manual": {
+                    "$ref": "#/definitions/models.BreakingNewsSettings"
+                },
+                "source": {
+                    "type": "string"
+                },
                 "text": {
                     "type": "string"
+                },
+                "window_hours": {
+                    "description": "WindowHours is 0 when a flagged article holds the banner indefinitely,\nwhich is the default; an admin sets a limit in Settings to opt in.",
+                    "type": "integer"
                 }
             }
         },
diff --git a/server/docs/swagger.json b/server/docs/swagger.json
index 6acbbd8..4c26911 100644
--- a/server/docs/swagger.json
+++ b/server/docs/swagger.json
@@ -4981,6 +4981,9 @@
         "models.BreakingNewsSettings": {
             "type": "object",
             "properties": {
+                "article_slug": {
+                    "type": "string"
+                },
                 "enabled": {
                     "type": "boolean"
                 },
@@ -4997,17 +5000,36 @@
                 },
                 "text": {
                     "type": "string"
+                },
+                "window_hours": {
+                    "type": "integer"
                 }
             }
         },
         "models.BreakingNewsSettingsResponse": {
             "type": "object",
             "properties": {
+                "article_slug": {
+                    "type": "string"
+                },
+                "article_title": {
+                    "type": "string"
+                },
                 "enabled": {
                     "type": "boolean"
                 },
+                "manual": {
+                    "$ref": "#/definitions/models.BreakingNewsSettings"
+                },
+                "source": {
+                    "type": "string"
+                },
                 "text": {
                     "type": "string"
+                },
+                "window_hours": {
+                    "description": "WindowHours is 0 when a flagged article holds the banner indefinitely,\nwhich is the default; an admin sets a limit in Settings to opt in.",
+                    "type": "integer"
                 }
             }
         },
diff --git a/server/docs/swagger.yaml b/server/docs/swagger.yaml
index 1993529..cadfcb0 100644
--- a/server/docs/swagger.yaml
+++ b/server/docs/swagger.yaml
@@ -477,6 +477,8 @@ definitions:
     type: object
   models.BreakingNewsSettings:
     properties:
+      article_slug:
+        type: string
       enabled:
         type: boolean
       text:
@@ -488,13 +490,28 @@ definitions:
         type: boolean
       text:
         type: string
+      window_hours:
+        type: integer
     type: object
   models.BreakingNewsSettingsResponse:
     properties:
+      article_slug:
+        type: string
+      article_title:
+        type: string
       enabled:
         type: boolean
+      manual:
+        $ref: '#/definitions/models.BreakingNewsSettings'
+      source:
+        type: string
       text:
         type: string
+      window_hours:
+        description: |-
+          WindowHours is 0 when a flagged article holds the banner indefinitely,
+          which is the default; an admin sets a limit in Settings to opt in.
+        type: integer
     type: object
   models.CategorySummary:
     properties:
diff --git a/server/internal/database/breaking_news_integration_test.go b/server/internal/database/breaking_news_integration_test.go
new file mode 100644
index 0000000..9e7077d
--- /dev/null
+++ b/server/internal/database/breaking_news_integration_test.go
@@ -0,0 +1,272 @@
+package database
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"testing"
+
+	"server/internal/models"
+
+	_ "github.com/go-sql-driver/mysql"
+)
+
+// The banner is resolved entirely in SQL -- the published predicate, the
+// window, and "newest wins" are all in one query -- so these need a real
+// MariaDB. The interesting case is the scheduled one: an article whose
+// pub_date is in the future must not raise the banner early, and UTC_TIMESTAMP
+// comparisons against DATETIME columns are exactly what a fake would get wrong.
+//
+// CMS_TEST_DSN='user:pw@tcp(127.0.0.1:3306)/cms_test?parseTime=true&multiStatements=true' go test ./internal/database/ -run BreakingNewsState -v
+func breakingNewsTestDB(t *testing.T) *sql.DB {
+	t.Helper()
+
+	dsn := os.Getenv("CMS_TEST_DSN")
+	if dsn == "" {
+		t.Skip("CMS_TEST_DSN not set; skipping breaking-news integration test")
+	}
+
+	conn, err := sql.Open("mysql", dsn)
+	if err != nil {
+		t.Fatalf("open test database: %v", err)
+	}
+	conn.SetMaxOpenConns(1)
+	if err := conn.Ping(); err != nil {
+		t.Fatalf("ping test database: %v", err)
+	}
+
+	ctx := context.Background()
+	var acquired sql.NullInt64
+	if err := conn.QueryRowContext(ctx, "SELECT GET_LOCK(?, 60)", "cms_integration_test_shared_tables").Scan(&acquired); err != nil {
+		t.Fatalf("acquire test lock: %v", err)
+	}
+	if !acquired.Valid || acquired.Int64 != 1 {
+		t.Fatal("timed out waiting for the shared table lock")
+	}
+	t.Cleanup(func() {
+		_, _ = conn.ExecContext(context.Background(), "SELECT RELEASE_LOCK(?)", "cms_integration_test_shared_tables")
+		conn.Close()
+	})
+
+	for _, stmt := range []string{
+		"DROP TABLE IF EXISTS articles",
+		"DROP TABLE IF EXISTS cms_settings",
+	} {
+		if _, err := conn.ExecContext(ctx, stmt); err != nil {
+			t.Fatalf("reset schema (%s): %v", stmt, err)
+		}
+	}
+
+	if _, err := conn.ExecContext(ctx, `
+		CREATE TABLE articles (
+			id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
+			title LONGTEXT,
+			slug VARCHAR(255) NOT NULL UNIQUE,
+			breaking_news BOOL,
+			pub_date DATETIME NULL,
+			scheduled_pub_date DATETIME NULL,
+			archived_at DATETIME NULL
+		) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+	`); err != nil {
+		t.Fatalf("create articles table: %v", err)
+	}
+	if err := EnsureSettingsTable(ctx, conn); err != nil {
+		t.Fatalf("ensure settings table: %v", err)
+	}
+	if err := EnsureArticlesBreakingNewsIndex(ctx, conn); err != nil {
+		t.Fatalf("ensure breaking-news index: %v", err)
+	}
+
+	// The settings cache is per-process and outlives the table drop above, so
+	// a value written by an earlier test would be served here as if it were
+	// still stored. Clearing it makes each case start from real state.
+	ResetSettingsCache()
+
+	return conn
+}
+
+// insertArticle adds one article. pubExpr and schedExpr are SQL expressions so
+// a case can say "an hour ago" or "in an hour" relative to the server clock
+// rather than the test's, which is the comparison the query actually makes.
+func insertArticle(t *testing.T, conn *sql.DB, slug, title string, breaking bool, pubExpr, schedExpr string) {
+	t.Helper()
+	flag := 0
+	if breaking {
+		flag = 1
+	}
+	_, err := conn.ExecContext(context.Background(),
+		"INSERT INTO articles (slug, title, breaking_news, pub_date, scheduled_pub_date) VALUES (?, ?, ?, "+pubExpr+", "+schedExpr+")",
+		slug, title, flag)
+	if err != nil {
+		t.Fatalf("insert article %s: %v", slug, err)
+	}
+}
+
+func TestBreakingNewsState_FallsBackToTheManualBanner(t *testing.T) {
+	conn := breakingNewsTestDB(t)
+	ctx := context.Background()
+
+	if err := SetBreakingNews(ctx, conn, models.BreakingNewsSettings{Enabled: true, Text: "Campus closed"}, breakingNewsWindowUnlimited); err != nil {
+		t.Fatalf("set manual banner: %v", err)
+	}
+
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state: %v", err)
+	}
+	if !state.Enabled || state.Text != "Campus closed" {
+		t.Errorf("expected the manual banner, got %+v", state.BreakingNewsSettings)
+	}
+	if state.Source != models.BreakingNewsSourceManual {
+		t.Errorf("source = %q, want %q", state.Source, models.BreakingNewsSourceManual)
+	}
+	if state.WindowHours != breakingNewsWindowUnlimited {
+		t.Errorf("window_hours = %d, want no limit", state.WindowHours)
+	}
+}
+
+func TestBreakingNewsState_PublishedArticleOverridesTheManualBanner(t *testing.T) {
+	conn := breakingNewsTestDB(t)
+	ctx := context.Background()
+
+	if err := SetBreakingNews(ctx, conn, models.BreakingNewsSettings{Enabled: true, Text: "Campus closed"}, breakingNewsWindowUnlimited); err != nil {
+		t.Fatalf("set manual banner: %v", err)
+	}
+	insertArticle(t, conn, "dragonfly", "Dragonfly headliner", true, "UTC_TIMESTAMP() - INTERVAL 10 MINUTE", "NULL")
+
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state: %v", err)
+	}
+	if !state.Enabled || state.Text != "Dragonfly headliner" {
+		t.Errorf("expected the article to drive the banner, got %+v", state.BreakingNewsSettings)
+	}
+	if state.Source != models.BreakingNewsSourceArticle {
+		t.Errorf("source = %q, want %q", state.Source, models.BreakingNewsSourceArticle)
+	}
+	// The slug rides on the banner itself, not just the settings view: it is
+	// what the public site builds the banner's link from.
+	if state.BreakingNewsSettings.ArticleSlug != "dragonfly" {
+		t.Errorf("article_slug = %q, want %q", state.BreakingNewsSettings.ArticleSlug, "dragonfly")
+	}
+	// The manual banner is preserved so the settings screen can still edit it.
+	if !state.Manual.Enabled || state.Manual.Text != "Campus closed" {
+		t.Errorf("manual banner was not preserved, got %+v", state.Manual)
+	}
+	// A hand-typed banner has no article behind it, so it must not inherit the
+	// overriding article's link.
+	if state.Manual.ArticleSlug != "" {
+		t.Errorf("manual banner carried a slug: %q", state.Manual.ArticleSlug)
+	}
+}
+
+func TestBreakingNewsState_ScheduledArticleWaitsForItsPubDate(t *testing.T) {
+	conn := breakingNewsTestDB(t)
+	ctx := context.Background()
+
+	// Exactly what an editor scheduling an 11am story leaves behind: flagged,
+	// not yet published, waiting on the scheduler tick.
+	insertArticle(t, conn, "tomorrow", "Scheduled scoop", true, "NULL", "UTC_TIMESTAMP() + INTERVAL 1 HOUR")
+
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state: %v", err)
+	}
+	if state.Enabled {
+		t.Fatalf("a scheduled article raised the banner early: %+v", state)
+	}
+
+	// Publish it the way the scheduler does, then it takes the banner with no
+	// further action -- that is the whole point of deriving it.
+	if _, err := conn.ExecContext(ctx,
+		"UPDATE articles SET pub_date = UTC_TIMESTAMP(), scheduled_pub_date = NULL WHERE slug = ?", "tomorrow"); err != nil {
+		t.Fatalf("publish article: %v", err)
+	}
+
+	state, err = GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state after publish: %v", err)
+	}
+	if !state.Enabled || state.Text != "Scheduled scoop" {
+		t.Errorf("expected the published article to take the banner, got %+v", state.BreakingNewsSettings)
+	}
+	if state.BreakingNewsSettings.ArticleSlug != "tomorrow" {
+		t.Errorf("article_slug = %q, want %q", state.BreakingNewsSettings.ArticleSlug, "tomorrow")
+	}
+}
+
+func TestBreakingNewsState_NewestFlaggedArticleWins(t *testing.T) {
+	conn := breakingNewsTestDB(t)
+	ctx := context.Background()
+
+	insertArticle(t, conn, "older", "Older breaking story", true, "UTC_TIMESTAMP() - INTERVAL 3 HOUR", "NULL")
+	insertArticle(t, conn, "newer", "Newer breaking story", true, "UTC_TIMESTAMP() - INTERVAL 1 HOUR", "NULL")
+
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state: %v", err)
+	}
+	if state.Text != "Newer breaking story" {
+		t.Errorf("text = %q, want the newer story", state.Text)
+	}
+}
+
+// The default. An article flagged months ago and never unticked still holds the
+// banner, because nothing was configured to take it down.
+func TestBreakingNewsState_KeepsAnOldArticleWhenNoWindowIsSet(t *testing.T) {
+	conn := breakingNewsTestDB(t)
+	ctx := context.Background()
+
+	insertArticle(t, conn, "ancient", "Long-forgotten emergency", true, "UTC_TIMESTAMP() - INTERVAL 30 DAY", "NULL")
+
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state: %v", err)
+	}
+	if !state.Enabled || state.Text != "Long-forgotten emergency" {
+		t.Errorf("expected the article to still hold the banner, got %+v", state.BreakingNewsSettings)
+	}
+	if state.WindowHours != breakingNewsWindowUnlimited {
+		t.Errorf("window_hours = %d, want no limit by default", state.WindowHours)
+	}
+}
+
+func TestBreakingNewsState_IgnoresArticlesOutsideAnAdminSetWindow(t *testing.T) {
+	conn := breakingNewsTestDB(t)
+	ctx := context.Background()
+
+	if err := SetBreakingNews(ctx, conn, models.BreakingNewsSettings{}, 2); err != nil {
+		t.Fatalf("set window: %v", err)
+	}
+	insertArticle(t, conn, "stale", "Yesterday's emergency", true, "UTC_TIMESTAMP() - INTERVAL 5 HOUR", "NULL")
+
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state: %v", err)
+	}
+	if state.Enabled {
+		t.Errorf("an article past the window still held the banner: %+v", state)
+	}
+	if state.Source != models.BreakingNewsSourceNone {
+		t.Errorf("source = %q, want %q", state.Source, models.BreakingNewsSourceNone)
+	}
+}
+
+func TestBreakingNewsState_IgnoresArchivedAndUnflaggedArticles(t *testing.T) {
+	conn := breakingNewsTestDB(t)
+	ctx := context.Background()
+
+	insertArticle(t, conn, "plain", "Not breaking", false, "UTC_TIMESTAMP() - INTERVAL 5 MINUTE", "NULL")
+	insertArticle(t, conn, "pulled", "Pulled story", true, "UTC_TIMESTAMP() - INTERVAL 5 MINUTE", "NULL")
+	if _, err := conn.ExecContext(ctx, "UPDATE articles SET archived_at = UTC_TIMESTAMP() WHERE slug = ?", "pulled"); err != nil {
+		t.Fatalf("archive article: %v", err)
+	}
+
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		t.Fatalf("get state: %v", err)
+	}
+	if state.Enabled {
+		t.Errorf("expected no banner, got %+v", state)
+	}
+}
diff --git a/server/internal/database/breaking_news_test.go b/server/internal/database/breaking_news_test.go
new file mode 100644
index 0000000..aebd1ff
--- /dev/null
+++ b/server/internal/database/breaking_news_test.go
@@ -0,0 +1,27 @@
+package database
+
+import (
+	"testing"
+)
+
+func TestNormalizeBreakingNewsWindow(t *testing.T) {
+	cases := []struct {
+		name  string
+		hours int
+		want  int
+	}{
+		{"zero is no limit", 0, breakingNewsWindowUnlimited},
+		{"negative is no limit", -3, breakingNewsWindowUnlimited},
+		{"in range is kept", 6, 6},
+		{"the maximum is kept", maxBreakingNewsWindowHours, maxBreakingNewsWindowHours},
+		{"above the maximum is clamped", maxBreakingNewsWindowHours + 1, maxBreakingNewsWindowHours},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := NormalizeBreakingNewsWindow(tc.hours); got != tc.want {
+				t.Errorf("NormalizeBreakingNewsWindow(%d) = %d, want %d", tc.hours, got, tc.want)
+			}
+		})
+	}
+}
diff --git a/server/internal/database/settings.go b/server/internal/database/settings.go
index 2b522f6..dada102 100644
--- a/server/internal/database/settings.go
+++ b/server/internal/database/settings.go
@@ -3,6 +3,7 @@ package database
 import (
 	"context"
 	"database/sql"
+	"strconv"
 	"strings"
 
 	"server/internal/models"
@@ -19,11 +20,40 @@ const (
 )
 
 // Breaking-news banner settings keys, stored in the cms_settings key-value table.
+//
+// These hold the MANUAL banner only. The banner an editor raises by flagging
+// an article is not stored anywhere: it is derived from the article on read,
+// so it appears exactly when the article publishes and disappears when the
+// flag comes off.
 const (
 	keyBreakingNewsEnabled = "breaking_news_enabled"
 	keyBreakingNewsText    = "breaking_news_text"
+	keyBreakingNewsWindow  = "breaking_news_window_hours"
 )
 
+// How long a flagged article keeps the banner after it publishes.
+//
+// Zero means no limit, and that is the default: the banner comes down when the
+// editor unticks the article, and nothing takes it down on their behalf. An
+// admin can set a limit in Settings if they want one, but it is opt-in --
+// a banner vanishing on a timer nobody chose would be its own surprise.
+const (
+	breakingNewsWindowUnlimited = 0
+	maxBreakingNewsWindowHours  = 24 * 7
+)
+
+// NormalizeBreakingNewsWindow clamps a requested window into the supported
+// range. A zero or negative value is "no limit".
+func NormalizeBreakingNewsWindow(hours int) int {
+	if hours <= 0 {
+		return breakingNewsWindowUnlimited
+	}
+	if hours > maxBreakingNewsWindowHours {
+		return maxBreakingNewsWindowHours
+	}
+	return hours
+}
+
 var seoSettingDefaults = map[string]string{
 	keySEOOGTitle:       "The Triangle | Drexel University's Independent Student Newspaper",
 	keySEOOGDescription: "Award-winning independent student journalism at Drexel University since 1925.",
@@ -67,9 +97,79 @@ func SetSiteTitle(ctx context.Context, conn *sql.DB, title string) error {
 	return setSetting(ctx, conn, "site_title", normalized)
 }
 
-// GetBreakingNews returns the breaking-news banner settings, defaulting to
-// disabled with empty text when unset.
+// GetBreakingNews returns the banner the public site should render.
+//
+// It is the effective half of GetBreakingNewsState -- the homepage only needs
+// to know whether to show a banner and what it says, not which of the two
+// sources produced it.
 func GetBreakingNews(ctx context.Context, conn *sql.DB) (models.BreakingNewsSettings, error) {
+	state, err := GetBreakingNewsState(ctx, conn)
+	if err != nil {
+		return models.BreakingNewsSettings{}, err
+	}
+	return state.BreakingNewsSettings, nil
+}
+
+// GetBreakingNewsState resolves the banner from both of its sources.
+//
+// A published article flagged breaking wins over the manual banner: it is the
+// more specific and more recent signal, and the newsroom flow the flag exists
+// for is "this story is the breaking story now". When two are live the newest
+// one holds the banner, since there is only one banner to hold.
+func GetBreakingNewsState(ctx context.Context, conn *sql.DB) (models.BreakingNewsState, error) {
+	manual, err := getManualBreakingNews(ctx, conn)
+	if err != nil {
+		return models.BreakingNewsState{}, err
+	}
+
+	window, err := GetBreakingNewsWindow(ctx, conn)
+	if err != nil {
+		return models.BreakingNewsState{}, err
+	}
+
+	state := models.BreakingNewsState{
+		BreakingNewsSettings: manual,
+		Source:               models.BreakingNewsSourceManual,
+		Manual:               manual,
+		WindowHours:          window,
+	}
+	if !manual.Enabled {
+		state.Source = models.BreakingNewsSourceNone
+	}
+
+	slug, title, err := latestBreakingArticle(ctx, conn, window)
+	if err != nil {
+		return models.BreakingNewsState{}, err
+	}
+	if title != "" {
+		state.BreakingNewsSettings = models.BreakingNewsSettings{
+			Enabled:     true,
+			Text:        title,
+			ArticleSlug: slug,
+		}
+		state.Source = models.BreakingNewsSourceArticle
+		state.ArticleTitle = title
+	}
+
+	return state, nil
+}
+
+// GetBreakingNewsWindow returns the configured banner window in hours.
+func GetBreakingNewsWindow(ctx context.Context, conn *sql.DB) (int, error) {
+	raw, err := getSetting(ctx, conn, keyBreakingNewsWindow, "")
+	if err != nil {
+		return 0, err
+	}
+	hours, convErr := strconv.Atoi(strings.TrimSpace(raw))
+	if convErr != nil {
+		// A blank or corrupt value is a missing setting, not a reason to fail
+		// the homepage; unset is the documented default anyway.
+		return breakingNewsWindowUnlimited, nil
+	}
+	return NormalizeBreakingNewsWindow(hours), nil
+}
+
+func getManualBreakingNews(ctx context.Context, conn *sql.DB) (models.BreakingNewsSettings, error) {
 	enabled, err := getSetting(ctx, conn, keyBreakingNewsEnabled, "false")
 	if err != nil {
 		return models.BreakingNewsSettings{}, err
@@ -86,8 +186,46 @@ func GetBreakingNews(ctx context.Context, conn *sql.DB) (models.BreakingNewsSett
 	}, nil
 }
 
-// SetBreakingNews persists the breaking-news banner settings.
-func SetBreakingNews(ctx context.Context, conn *sql.DB, s models.BreakingNewsSettings) error {
+// latestBreakingArticle returns the newest published article flagged breaking,
+// or empty strings when none is.
+//
+// The published predicate is the same one every other public read uses, which
+// is the whole point: a scheduled article starts driving the banner at the
+// same instant it starts being readable, with no separate publish hook to
+// drift out of step with it.
+//
+// windowHours of 0 is no limit, in which case the age clause is left off the
+// query rather than passed as a sentinel -- `INTERVAL 0 HOUR` would exclude
+// every article instead of including them all.
+func latestBreakingArticle(ctx context.Context, conn *sql.DB, windowHours int) (string, string, error) {
+	query := `
+		SELECT slug, title
+		FROM articles
+		WHERE breaking_news = 1
+		  AND pub_date IS NOT NULL
+		  AND pub_date <= UTC_TIMESTAMP()
+		  AND archived_at IS NULL
+	`
+	args := []any{}
+	if windowHours > 0 {
+		query += "  AND pub_date > UTC_TIMESTAMP() - INTERVAL ? HOUR\n"
+		args = append(args, windowHours)
+	}
+	query += "\tORDER BY pub_date DESC, id DESC\n\tLIMIT 1"
+
+	var slug, title sql.NullString
+	err := conn.QueryRowContext(ctx, query, args...).Scan(&slug, &title)
+	if err == sql.ErrNoRows {
+		return "", "", nil
+	}
+	if err != nil {
+		return "", "", err
+	}
+	return strings.TrimSpace(slug.String), strings.TrimSpace(title.String), nil
+}
+
+// SetBreakingNews persists the manual breaking-news banner and its window.
+func SetBreakingNews(ctx context.Context, conn *sql.DB, s models.BreakingNewsSettings, windowHours int) error {
 	enabled := "false"
 	if s.Enabled {
 		enabled = "true"
@@ -95,7 +233,10 @@ func SetBreakingNews(ctx context.Context, conn *sql.DB, s models.BreakingNewsSet
 	if err := setSetting(ctx, conn, keyBreakingNewsEnabled, enabled); err != nil {
 		return err
 	}
-	return setSetting(ctx, conn, keyBreakingNewsText, strings.TrimSpace(s.Text))
+	if err := setSetting(ctx, conn, keyBreakingNewsText, strings.TrimSpace(s.Text)); err != nil {
+		return err
+	}
+	return setSetting(ctx, conn, keyBreakingNewsWindow, strconv.Itoa(NormalizeBreakingNewsWindow(windowHours)))
 }
 
 // getSetting reads a single cms_settings value, returning fallback when the key
diff --git a/server/internal/database/users.go b/server/internal/database/users.go
index 8550378..900b485 100644
--- a/server/internal/database/users.go
+++ b/server/internal/database/users.go
@@ -45,6 +45,25 @@ func EnsureArticlesPublishedIndex(ctx context.Context, conn *sql.DB) error {
 	return err
 }
 
+// EnsureArticlesBreakingNewsIndex indexes the banner lookup.
+//
+// GetBreakingNewsState runs on every homepage render, and its predicate is
+// `breaking_news = 1` over the whole migrated corpus -- tens of thousands of
+// rows scanned to find the handful ever flagged, or none at all, which is the
+// common case. Leading on the flag lets the optimizer skip straight to those
+// rows, and pub_date riding along orders them inside the index so the LIMIT 1
+// needs no sort.
+//
+// Non-fatal like the other index builders: the banner resolves correctly
+// without it, just by reading more of the table to do it.
+func EnsureArticlesBreakingNewsIndex(ctx context.Context, conn *sql.DB) error {
+	_, err := conn.ExecContext(ctx, `
+		ALTER TABLE articles
+		ADD INDEX IF NOT EXISTS idx_articles_breaking_news (`+"`breaking_news`, `pub_date`"+`)
+	`)
+	return err
+}
+
 // EnsureArticlesSlugIndex indexes the column every article is addressed by:
 // the detail endpoint, the comment thread, the permalink check, the
 // featured-article write. Without it each of those is a full scan of the
diff --git a/server/internal/handlers/breaking_news_settings_integration_test.go b/server/internal/handlers/breaking_news_settings_integration_test.go
new file mode 100644
index 0000000..21d3889
--- /dev/null
+++ b/server/internal/handlers/breaking_news_settings_integration_test.go
@@ -0,0 +1,178 @@
+package handlers
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	db "server/internal/database"
+
+	_ "github.com/go-sql-driver/mysql"
+)
+
+// CMS_TEST_DSN='user:pw@tcp(127.0.0.1:3306)/cms_test?parseTime=true&multiStatements=true' go test ./internal/handlers/ -run BreakingNewsSettings -v
+func breakingNewsSettingsTestDB(t *testing.T) *sql.DB {
+	t.Helper()
+
+	dsn := os.Getenv("CMS_TEST_DSN")
+	if dsn == "" {
+		t.Skip("CMS_TEST_DSN not set; skipping breaking-news settings integration test")
+	}
+
+	conn, err := sql.Open("mysql", dsn)
+	if err != nil {
+		t.Fatalf("open test database: %v", err)
+	}
+	conn.SetMaxOpenConns(1)
+	if err := conn.Ping(); err != nil {
+		t.Fatalf("ping test database: %v", err)
+	}
+
+	ctx := context.Background()
+	var acquired sql.NullInt64
+	if err := conn.QueryRowContext(ctx, "SELECT GET_LOCK(?, 60)", "cms_integration_test_shared_tables").Scan(&acquired); err != nil {
+		t.Fatalf("acquire test lock: %v", err)
+	}
+	if !acquired.Valid || acquired.Int64 != 1 {
+		t.Fatal("timed out waiting for the shared table lock")
+	}
+	t.Cleanup(func() {
+		_, _ = conn.ExecContext(context.Background(), "SELECT RELEASE_LOCK(?)", "cms_integration_test_shared_tables")
+		conn.Close()
+	})
+
+	for _, stmt := range []string{
+		"DROP TABLE IF EXISTS articles",
+		"DROP TABLE IF EXISTS cms_settings",
+	} {
+		if _, err := conn.ExecContext(ctx, stmt); err != nil {
+			t.Fatalf("reset schema (%s): %v", stmt, err)
+		}
+	}
+	if _, err := conn.ExecContext(ctx, `
+		CREATE TABLE articles (
+			id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
+			title LONGTEXT,
+			slug VARCHAR(255) NOT NULL UNIQUE,
+			breaking_news BOOL,
+			pub_date DATETIME NULL,
+			archived_at DATETIME NULL
+		) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+	`); err != nil {
+		t.Fatalf("create articles table: %v", err)
+	}
+	if err := db.EnsureSettingsTable(ctx, conn); err != nil {
+		t.Fatalf("ensure settings table: %v", err)
+	}
+	db.ResetSettingsCache()
+
+	return conn
+}
+
+func patchBreakingNews(t *testing.T, conn *sql.DB, body string) *httptest.ResponseRecorder {
+	t.Helper()
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodPatch, "/v1/settings/breaking-news", strings.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	PatchBreakingNews(conn).ServeHTTP(rec, req)
+	db.ResetSettingsCache()
+	return rec
+}
+
+func decodeBreakingNews(t *testing.T, rec *httptest.ResponseRecorder) map[string]any {
+	t.Helper()
+	var payload map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response %q: %v", rec.Body.String(), err)
+	}
+	return payload
+}
+
+// window_hours is optional, and the settings screen is not the only thing that
+// can toggle the banner. A plain enable/disable must not quietly reset how long
+// flagged articles hold the homepage.
+func TestBreakingNewsSettingsHTTP_OmittedWindowIsPreserved(t *testing.T) {
+	conn := breakingNewsSettingsTestDB(t)
+
+	if rec := patchBreakingNews(t, conn, `{"enabled":true,"text":"Campus closed","window_hours":6}`); rec.Code != http.StatusOK {
+		t.Fatalf("set window: status %d, body %s", rec.Code, rec.Body.String())
+	}
+
+	rec := patchBreakingNews(t, conn, `{"enabled":false,"text":""}`)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("disable banner: status %d, body %s", rec.Code, rec.Body.String())
+	}
+	if got := decodeBreakingNews(t, rec)["window_hours"]; got != float64(6) {
+		t.Errorf("window_hours = %v, want 6", got)
+	}
+}
+
+// 0 is how an admin turns the limit back off, so it has to round-trip rather
+// than fall back to some built-in duration.
+func TestBreakingNewsSettingsHTTP_ZeroWindowClearsTheLimit(t *testing.T) {
+	conn := breakingNewsSettingsTestDB(t)
+
+	if rec := patchBreakingNews(t, conn, `{"enabled":false,"text":"","window_hours":6}`); rec.Code != http.StatusOK {
+		t.Fatalf("set window: status %d, body %s", rec.Code, rec.Body.String())
+	}
+
+	rec := patchBreakingNews(t, conn, `{"enabled":false,"text":"","window_hours":0}`)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("clear window: status %d, body %s", rec.Code, rec.Body.String())
+	}
+	if got := decodeBreakingNews(t, rec)["window_hours"]; got != float64(0) {
+		t.Errorf("window_hours = %v, want 0", got)
+	}
+}
+
+func TestBreakingNewsSettingsHTTP_RejectsANegativeWindow(t *testing.T) {
+	conn := breakingNewsSettingsTestDB(t)
+
+	rec := patchBreakingNews(t, conn, `{"enabled":false,"text":"","window_hours":-1}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
+	}
+}
+
+// The admin saves a manual banner; an article is already holding the homepage.
+// Echoing the request back would tell them the banner says something it does
+// not, so the response is re-resolved.
+func TestBreakingNewsSettingsHTTP_ResponseReflectsAnOverridingArticle(t *testing.T) {
+	conn := breakingNewsSettingsTestDB(t)
+	if _, err := conn.ExecContext(context.Background(),
+		"INSERT INTO articles (slug, title, breaking_news, pub_date) VALUES (?, ?, 1, UTC_TIMESTAMP() - INTERVAL 5 MINUTE)",
+		"dragonfly", "Dragonfly headliner"); err != nil {
+		t.Fatalf("seed article: %v", err)
+	}
+
+	rec := patchBreakingNews(t, conn, `{"enabled":true,"text":"Campus closed"}`)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, body %s", rec.Code, rec.Body.String())
+	}
+
+	payload := decodeBreakingNews(t, rec)
+	if payload["source"] != "article" {
+		t.Errorf("source = %v, want %q", payload["source"], "article")
+	}
+	if payload["text"] != "Dragonfly headliner" {
+		t.Errorf("text = %v, want the article headline", payload["text"])
+	}
+	manual, _ := payload["manual"].(map[string]any)
+	if manual["text"] != "Campus closed" {
+		t.Errorf("manual.text = %v, want the banner that was just saved", manual["text"])
+	}
+}
+
+func TestBreakingNewsSettingsHTTP_RejectsAnEnabledBannerWithNoText(t *testing.T) {
+	conn := breakingNewsSettingsTestDB(t)
+
+	rec := patchBreakingNews(t, conn, `{"enabled":true,"text":"   "}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
+	}
+}
diff --git a/server/internal/handlers/settings.go b/server/internal/handlers/settings.go
index a515be4..e7e6776 100644
--- a/server/internal/handlers/settings.go
+++ b/server/internal/handlers/settings.go
@@ -73,13 +73,16 @@ func PatchSiteSettings(conn *sql.DB) http.Handler {
 // @Router /v1/settings/breaking-news [get]
 func GetBreakingNews(conn *sql.DB) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		settings, err := db.GetBreakingNews(r.Context(), conn)
+		state, err := db.GetBreakingNewsState(r.Context(), conn)
 		if err != nil {
 			writeError(w, http.StatusInternalServerError, "failed to fetch breaking-news settings")
 			return
 		}
+		// The 60s public cache is what bounds how long an article-driven banner
+		// lags its article, and it is the same 60s the scheduler ticks on, so a
+		// scheduled story's banner lands within a tick of the story itself.
 		setAlwaysPublicCache(w)
-		writeJSON(w, http.StatusOK, settings)
+		writeJSON(w, http.StatusOK, state)
 	})
 }
 
@@ -107,16 +110,43 @@ func PatchBreakingNews(conn *sql.DB) http.Handler {
 			return
 		}
 
-		if err := db.SetBreakingNews(r.Context(), conn, body); err != nil {
+		// Omitted means "leave the window alone", so it is read back rather
+		// than defaulted -- a plain enable/disable must not silently reset it.
+		window, err := db.GetBreakingNewsWindow(r.Context(), conn)
+		if err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to fetch breaking-news settings")
+			return
+		}
+		if body.WindowHours != nil {
+			// 0 is the meaningful "no limit" value, so only a negative one is
+			// a mistake worth rejecting.
+			if *body.WindowHours < 0 {
+				writeError(w, http.StatusBadRequest, "window_hours cannot be negative")
+				return
+			}
+			window = db.NormalizeBreakingNewsWindow(*body.WindowHours)
+		}
+
+		manual := models.BreakingNewsSettings{Enabled: body.Enabled, Text: body.Text}
+		if err := db.SetBreakingNews(r.Context(), conn, manual, window); err != nil {
 			writeError(w, http.StatusInternalServerError, "failed to update breaking-news settings")
 			return
 		}
-		state := "disabled"
+		logState := "disabled"
 		if body.Enabled {
-			state = "enabled"
+			logState = "enabled"
+		}
+		activity.LogRequest(r, "settings_changed", "Breaking-news banner updated", "breaking_news", logState)
+
+		// Re-resolved rather than echoed: a flagged article may be overriding
+		// the manual banner that was just saved, and the admin should see the
+		// banner the public site is actually rendering.
+		state, err := db.GetBreakingNewsState(r.Context(), conn)
+		if err != nil {
+			writeError(w, http.StatusInternalServerError, "failed to fetch breaking-news settings")
+			return
 		}
-		activity.LogRequest(r, "settings_changed", "Breaking-news banner updated", "breaking_news", state)
-		writeJSON(w, http.StatusOK, body)
+		writeJSON(w, http.StatusOK, state)
 	})
 }
 
diff --git a/server/internal/models/api_responses.go b/server/internal/models/api_responses.go
index 493b621..a47a433 100644
--- a/server/internal/models/api_responses.go
+++ b/server/internal/models/api_responses.go
@@ -302,15 +302,57 @@ type SiteSettingsPatchRequest struct {
 }
 
 // BreakingNewsSettings controls the breaking-news banner shown on the public
-// homepage: whether it is visible and the text it displays.
+// homepage: whether it is visible, the text it displays, and the article it
+// links to.
+//
+// ArticleSlug is the slug alone, not a path: the public site owns its own URL
+// shape (it routes articles under /article/), and it already composes links
+// this way for developing stories. It is empty for a hand-typed banner, which
+// has no article behind it and renders as plain text.
 type BreakingNewsSettings struct {
-	Enabled bool   `json:"enabled"`
-	Text    string `json:"text"`
+	Enabled     bool   `json:"enabled"`
+	Text        string `json:"text"`
+	ArticleSlug string `json:"article_slug,omitempty"`
 }
 
-type BreakingNewsSettingsResponse = BreakingNewsSettings
+// Sources a banner can come from, in the order GetBreakingNewsState resolves
+// them: a published article flagged breaking wins over the hand-typed banner.
+const (
+	BreakingNewsSourceNone    = "none"
+	BreakingNewsSourceManual  = "manual"
+	BreakingNewsSourceArticle = "article"
+)
 
-type BreakingNewsSettingsPatchRequest = BreakingNewsSettings
+// BreakingNewsState is the banner as resolved for a request: the effective
+// Enabled/Text the public site renders, plus what produced them.
+//
+// The banner is derived, not stored. An article flagged breaking drives it
+// from the moment it is published -- which is what makes scheduling work:
+// nothing has to fire at publish time, because the article's pub_date passing
+// is itself the switch. Manual is the hand-typed fallback an admin sets in
+// Settings, kept separate so the settings screen can still edit it while an
+// article is overriding it.
+type BreakingNewsState struct {
+	BreakingNewsSettings
+	Source       string               `json:"source"`
+	ArticleTitle string               `json:"article_title,omitempty"`
+	Manual       BreakingNewsSettings `json:"manual"`
+	// WindowHours is 0 when a flagged article holds the banner indefinitely,
+	// which is the default; an admin sets a limit in Settings to opt in.
+	WindowHours int `json:"window_hours"`
+}
+
+type BreakingNewsSettingsResponse = BreakingNewsState
+
+// BreakingNewsSettingsPatchRequest edits the manual banner only; the
+// article-driven banner is changed by flagging or unflagging the article.
+// WindowHours is optional so a caller that only toggles the banner does not
+// have to know the current window; 0 means the banner has no time limit.
+type BreakingNewsSettingsPatchRequest struct {
+	Enabled     bool   `json:"enabled"`
+	Text        string `json:"text"`
+	WindowHours *int   `json:"window_hours,omitempty"`
+}
 
 // HomepageCarouselSlide is one public Splide carousel item for Scalene's
 // homepage. ImageURL may be empty for a text-only slide.
diff --git a/server/main.go b/server/main.go
index b02f5de..6974936 100644
--- a/server/main.go
+++ b/server/main.go
@@ -138,6 +138,9 @@ func main() {
 	if err := database.EnsureArticleAuthorsIndex(context.Background(), db); err != nil {
 		slog.Error("failed to index article authors; byline lookups scan the join table", "error", err)
 	}
+	if err := database.EnsureArticlesBreakingNewsIndex(context.Background(), db); err != nil {
+		slog.Error("failed to index breaking-news articles; the homepage banner lookup scans the table", "error", err)
+	}
 
 	// Deliberately not fatal, and deliberately after the column migration: the
 	// first FULLTEXT index on `articles` rebuilds the table, which on the