Refactor the yaml data package to group data sources by category

Implement friendly time formatting in select modules
Add an hourly forecast module and adjust the daily summary for consistency
2026-06-10 11:50:22 -05:00 · 2026-06-10 10:36:52 -05:00 · 2026-06-10 10:00:36 -05:00 · 2026-06-10 09:35:39 -05:00 · 2026-06-10 09:24:06 -05:00
30 changed files with 1097 additions and 202 deletions
--- a/docs/config.md
+++ b/docs/config.md
@@ -201,6 +201,7 @@ reports:
        options:
          sections:
            - short_term
+      - hourly_forecast
 ```

 Unknown reports, unknown modules, duplicate modules, incompatible report/module
--- a/docs/internal/briefing.md
+++ b/docs/internal/briefing.md
@@ -27,8 +27,8 @@ Outputs:
 - `ModuleDefinition` values with module ID, stanza name, option type,
  supported reports, fact requirements, missing-data behavior, and builder
 - `module.Output` values for source-oriented stanzas:
-  `metadata`, `current_conditions`, `narrative_forecast`, `alert_digest`,
-  `area_forecast_discussion`, and `weather_story`
+  `metadata`, `current_conditions`, `narrative_forecast`, `hourly_forecast`,
+  `alert_digest`, `area_forecast_discussion`, and `weather_story`
 - `module.Output` values for derived stanzas:
  `derived_daily_summary`, `derived_daypart_summaries`, `precip_timing`,
  `outdoor_windows`, and `tomorrow_planning`
@@ -36,6 +36,10 @@ Outputs:
 Every registered composition entry has a builder. Unknown or unimplemented
 module IDs fail validation instead of being skipped.

+Prompt-facing module values use local, human-readable date and time labels
+where the LLM is expected to reason about report content. Canonical timestamps
+remain in report metadata, source provenance, and integration artifacts.
+
 ## Boundaries

 - This package selects and shapes already-collected weather facts for prompts.
--- a/docs/internal/module.md
+++ b/docs/internal/module.md
@@ -32,6 +32,7 @@ The registry recognizes these IDs:
 - `metadata`
 - `current_conditions`
 - `narrative_forecast`
+- `hourly_forecast`
 - `derived_daily_summary`
 - `derived_daypart_summaries`
 - `precip_timing`
--- a/docs/internal/prompt-input.md
+++ b/docs/internal/prompt-input.md
@@ -24,7 +24,8 @@ Inputs:
 Outputs:

 - `promptinput.Package` with schema version, RunID, report metadata, named
-  module stanzas, Recent Changes, and source warnings
+  module stanzas grouped for prompt presentation, Recent Changes, and source
+  warnings
 - YAML bytes from `promptinput.MarshalYAML`
 - YAML file written atomically by `promptinput.Save`

@@ -38,14 +39,37 @@ report:
  prompt_id: <prompt_id>
 briefing:
  metadata: {}
-  current_conditions: {}
+  applicable_risk_products:
+    alert_digest: {}
+  derived_summaries:
+    derived_daily_summary: {}
+    derived_daypart_summaries: {}
+    precip_timing: {}
+    outdoor_windows: {}
+  narrative_products:
    narrative_forecast: {}
+    area_forecast_discussion: {}
+    weather_story: {}
+  raw_data:
+    current_conditions: {}
+    hourly_forecast: {}
 recent_changes:
  items: []
 ```

-The `briefing` mapping contains named module stanzas. Stanza order follows the
-module snapshot output order.
+The `briefing` mapping keeps `metadata` directly under `briefing` and groups
+weather module stanzas under prompt-facing categories. This grouping is a YAML
+presentation concern only: module snapshots remain flat, and loaded
+`promptinput.Package` values expose flat stanza names in `Briefing.Values`.
+Within each category, stanza order follows the module snapshot output order.
+
+Current categories are:
+
+- `applicable_risk_products`: location-applicable alerts, warnings, outlooks,
+  discussions, and similar risk products.
+- `derived_summaries`: deterministic summaries and calculated report facts.
+- `narrative_products`: official narrative text products and forecast stories.
+- `raw_data`: minimally transformed underlying weather data.

 ## Boundaries

@@ -91,6 +115,7 @@ Inspect:
 ## Invariants

 - Scriptorium receives structured YAML through `--input data_package=<path>`.
- Module stanza order is deterministic for generated snapshots.
+- Module stanza order is deterministic within each prompt-facing category.
+- Every non-metadata module stanza has exactly one prompt-input category.
 - Recent Changes are provided by `internal/changes`; this package does not
  infer changes from rendered report text.
--- a/examples/config.yml
+++ b/examples/config.yml
@@ -86,3 +86,4 @@ reports:
            - long_term
      - weather_story
      - outdoor_windows
+      - hourly_forecast
--- a/internal/app/app_test.go
+++ b/internal/app/app_test.go
@@ -160,19 +160,32 @@ func TestGenerateReportWritesReportAndPreflight(t *testing.T) {
 	}
 	if !strings.Contains(string(data), "schema_version: weatherreporter.data_package.v2") ||
 		!strings.Contains(string(data), "recent_changes:") ||
+		!strings.Contains(string(data), "applicable_risk_products:") ||
+		!strings.Contains(string(data), "derived_summaries:") ||
+		!strings.Contains(string(data), "narrative_products:") ||
+		!strings.Contains(string(data), "raw_data:") ||
 		!strings.Contains(string(data), "current_conditions:") ||
 		!strings.Contains(string(data), "narrative_forecast:") ||
+		!strings.Contains(string(data), "hourly_forecast:") ||
 		!strings.Contains(string(data), "area_forecast_discussion:") {
 		t.Fatalf("data package missing expected content:\n%s", string(data))
 	}
 	if strings.Contains(string(data), "source_warnings:") {
 		t.Fatalf("data package has source warnings, want none for complete fetched sources:\n%s", string(data))
 	}
-	currentIndex := strings.Index(string(data), "  current_conditions:")
-	narrativeIndex := strings.Index(string(data), "  narrative_forecast:")
+	riskIndex := strings.Index(string(data), "  applicable_risk_products:")
+	derivedIndex := strings.Index(string(data), "  derived_summaries:")
+	narrativeIndex := strings.Index(string(data), "  narrative_products:")
+	rawIndex := strings.Index(string(data), "  raw_data:")
+	alertIndex := strings.Index(string(data), "    alert_digest:")
 	summaryIndex := strings.Index(string(data), "    derived_daily_summary:")
-	if currentIndex < 0 || narrativeIndex < 0 || summaryIndex < 0 || !(currentIndex < narrativeIndex && narrativeIndex < summaryIndex) {
-		t.Fatalf("data package stanza order is wrong, want current_conditions then narrative_forecast then derived_daily_summary:\n%s", string(data))
+	storyIndex := strings.Index(string(data), "    weather_story:")
+	currentIndex := strings.Index(string(data), "    current_conditions:")
+	hourlyIndex := strings.Index(string(data), "    hourly_forecast:")
+	if riskIndex < 0 || derivedIndex < 0 || narrativeIndex < 0 || rawIndex < 0 || alertIndex < 0 || summaryIndex < 0 || storyIndex < 0 || currentIndex < 0 || hourlyIndex < 0 ||
+		!(riskIndex < derivedIndex && derivedIndex < narrativeIndex && narrativeIndex < rawIndex) ||
+		!(riskIndex < alertIndex && derivedIndex < summaryIndex && narrativeIndex < storyIndex && rawIndex < currentIndex && currentIndex < hourlyIndex) {
+		t.Fatalf("data package grouping is wrong, want categorized prompt stanzas:\n%s", string(data))
 	}
 	savedDataPackage, err := promptinput.LoadYAML(data)
 	if err != nil {
@@ -192,6 +205,10 @@ func TestGenerateReportWritesReportAndPreflight(t *testing.T) {
 	if !ok || narrative["product"] != "narrative" || !strings.Contains(string(data), "Morning storms, then partly sunny.") {
 		t.Fatalf("data package narrative forecast = %#v, want narrative forecast", savedDataPackage.Briefing.Values["narrative_forecast"])
 	}
+	hourly, ok := savedDataPackage.Briefing.Values["hourly_forecast"].(map[string]any)
+	if !ok || hourly["product"] != "hourly" || !strings.Contains(string(data), "Showers and thunderstorms") {
+		t.Fatalf("data package hourly forecast = %#v, want hourly forecast", savedDataPackage.Briefing.Values["hourly_forecast"])
+	}
 	story, ok := savedDataPackage.Briefing.Values["weather_story"].(map[string]any)
 	if !ok || story["title"] != "Several Chances for Rain Through Monday" {
 		t.Fatalf("data package weather story = %#v, want weather story title", savedDataPackage.Briefing.Values["weather_story"])
@@ -679,7 +696,7 @@ func TestGenerateTomorrowReportUsesTomorrowBriefingDate(t *testing.T) {
 	if err != nil {
 		t.Fatalf("decode daily summary: %v", err)
 	}
-	if !ok || dailySummary["date"] != "2026-05-30" {
+	if !ok || dailySummary["date"] != "Saturday, May 30, 2026" {
 		t.Fatalf("daily summary = %#v, want tomorrow date", dailySummary)
 	}
 	if _, ok := result.ModuleSnapshot.LookupStanza("tomorrow_planning"); !ok {
@@ -1359,11 +1376,12 @@ func priorDailyModuleSnapshot(t *testing.T, resolved report.Resolved) module.Sna
 			"date":                            resolved.ValidPeriod.Start.Format(timeutil.DateLayout),
 			"low_temp_f":                      low,
 			"high_temp_f":                     high,
-			"max_pop_percent": precip,
+			"daily_precipitation_probability": precip,
 		}},
 		{ID: module.DerivedDaypartSummaries, StanzaName: "derived_daypart_summaries", Value: map[string]any{
 			"morning": map[string]any{
-				"period":       timeutil.Period{Start: resolved.ValidPeriod.Start.Add(6 * time.Hour), End: resolved.ValidPeriod.Start.Add(10 * time.Hour)},
+				"date":         resolved.ValidPeriod.Start.Format(timeutil.DateLayout),
+				"period":       resolved.ValidPeriod.Start.Add(6*time.Hour).Format("2006-01-02 at 3:04 PM") + " to " + resolved.ValidPeriod.Start.Add(10*time.Hour).Format("2006-01-02 at 3:04 PM"),
 				"temp_range_f": "50-58",
 			},
 		}},
@@ -1385,7 +1403,8 @@ func priorOutlookModuleSnapshot(t *testing.T, date string) module.Snapshot {
 	snapshot, err := module.NewSnapshot([]module.Output{
 		{ID: module.DerivedDaypartSummaries, StanzaName: "derived_daypart_summaries", Value: map[string]any{
 			date + "_morning": map[string]any{
-				"period":          timeutil.Period{Start: mustParse(date + "T06:00:00Z"), End: mustParse(date + "T10:00:00Z")},
+				"date":            date,
+				"period":          date + " at 6:00 AM to " + date + " at 10:00 AM",
 				"temp_range_f":    "50-58",
 				"max_pop_percent": precip,
 				"max_pop_time":    "6 AM",
--- a/internal/briefing/base_modules_test.go
+++ b/internal/briefing/base_modules_test.go
@@ -25,6 +25,7 @@ func TestBaseModulesBuildAvailableSourceOutputs(t *testing.T) {
 		{id: module.Metadata, stanza: "metadata"},
 		{id: module.CurrentConditions, stanza: "current_conditions"},
 		{id: module.NarrativeForecast, stanza: "narrative_forecast"},
+		{id: module.HourlyForecast, stanza: "hourly_forecast"},
 		{id: module.AlertDigest, stanza: "alert_digest"},
 		{id: module.AreaForecastDiscussion, stanza: "area_forecast_discussion"},
 		{id: module.WeatherStory, stanza: "weather_story"},
@@ -45,6 +46,57 @@ func TestBaseModulesBuildAvailableSourceOutputs(t *testing.T) {
 	}
 }

+func TestHourlyForecastModuleUsesValidPeriodHourlyPeriods(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := testModuleContext()
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.HourlyForecast})
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	value := moduleValue[HourlyForecastModule](t, output)
+	if value.Product != "hourly" || value.SourceLocationID != "test-grid" || len(value.Periods) != 1 {
+		t.Fatalf("HourlyForecast = %#v, want hourly metadata and one valid-period period", value)
+	}
+	period := value.Periods[0]
+	if period.TextDescription != "Showers likely." || period.TemperatureF == nil || *period.TemperatureF != 76 {
+		t.Fatalf("HourlyForecast period = %#v, want hourly period facts", period)
+	}
+	if period.StartTime != "2026-05-29 at 8:00 AM" || period.EndTime != "2026-05-29 at 9:00 AM" {
+		t.Fatalf("HourlyForecast period times = %q/%q, want friendly local time labels", period.StartTime, period.EndTime)
+	}
+	if period.WindDirection != "S" || period.ProbabilityOfPrecipitationPercent == nil || *period.ProbabilityOfPrecipitationPercent != 70 {
+		t.Fatalf("HourlyForecast period = %#v, want compass wind and precip chance", period)
+	}
+	data, err := json.Marshal(output.Value)
+	if err != nil {
+		t.Fatalf("Marshal hourly forecast: %v", err)
+	}
+	jsonText := string(data)
+	for _, field := range []string{"source_location_id", "text_description", "temperature_f", "wind_direction", "probability_of_precipitation_percent", "relative_humidity_percent"} {
+		if !strings.Contains(jsonText, field) {
+			t.Fatalf("hourly json = %s, want field %s", jsonText, field)
+		}
+	}
+	if strings.Contains(jsonText, "wind_direction_degrees") || strings.Contains(jsonText, "Tomorrow") {
+		t.Fatalf("hourly json = %s, want valid-period prompt fields only", jsonText)
+	}
+	if strings.Contains(jsonText, `"start_time":"2026-05-29T`) || strings.Contains(jsonText, `"end_time":"2026-05-29T`) {
+		t.Fatalf("hourly json = %s, want friendly local start/end times", jsonText)
+	}
+}
+
+func TestHourlyForecastModuleRejectsUnsupportedReports(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := testModuleContext()
+	ctx.Resolved.Definition = report.DefaultRegistry().MustLookup(report.Weekend)
+
+	_, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.HourlyForecast})
+	if err == nil || !strings.Contains(err.Error(), `module "hourly_forecast" is not compatible with report "weekend"`) {
+		t.Fatalf("BuildModule() error = %v, want incompatible report", err)
+	}
+}
+
 func TestNarrativeForecastModuleUsesValidPeriodNarrativePeriods(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := testModuleContext()
@@ -61,19 +113,31 @@ func TestNarrativeForecastModuleUsesValidPeriodNarrativePeriods(t *testing.T) {
 	if period.Name != "Today" || period.TextDescription != "Morning storms, then partly sunny." {
 		t.Fatalf("NarrativeForecast period = %#v, want Today narrative", period)
 	}
+	if period.StartTime != "2026-05-29 at 6:00 AM" || period.EndTime != "2026-05-29 at 6:00 PM" {
+		t.Fatalf("NarrativeForecast period times = %q/%q, want friendly local time labels", period.StartTime, period.EndTime)
+	}
 	if period.IsDay == nil || !*period.IsDay || period.TemperatureF == nil || *period.TemperatureF != 81 || period.ProbabilityOfPrecipitationPercent == nil || *period.ProbabilityOfPrecipitationPercent != 60 {
 		t.Fatalf("NarrativeForecast period = %#v, want day, temperature, and precip values", period)
 	}
+	if period.WindDirection != "NE" {
+		t.Fatalf("NarrativeForecast period wind direction = %q, want NE", period.WindDirection)
+	}
 	data, err := json.Marshal(output.Value)
 	if err != nil {
 		t.Fatalf("Marshal narrative forecast: %v", err)
 	}
 	jsonText := string(data)
-	for _, field := range []string{"source_location_id", "text_description", "temperature_f", "wind_speed_mph", "probability_of_precipitation_percent"} {
+	for _, field := range []string{"source_location_id", "text_description", "temperature_f", "wind_speed_mph", "wind_direction", "probability_of_precipitation_percent"} {
 		if !strings.Contains(jsonText, field) {
 			t.Fatalf("narrative json = %s, want field %s", jsonText, field)
 		}
 	}
+	if strings.Contains(jsonText, "wind_direction_degrees") {
+		t.Fatalf("narrative json = %s, want compass wind_direction without degrees field", jsonText)
+	}
+	if strings.Contains(jsonText, `"start_time":"2026-05-29T`) || strings.Contains(jsonText, `"end_time":"2026-05-29T`) {
+		t.Fatalf("narrative json = %s, want friendly local start/end times", jsonText)
+	}
 	if strings.Contains(jsonText, "Tomorrow night") {
 		t.Fatalf("narrative json = %s, want only valid-period narrative periods", jsonText)
 	}
@@ -133,16 +197,22 @@ func TestCurrentConditionsModuleUsesSnakeCaseUnitFields(t *testing.T) {
 	if value.ConditionText != "Partly cloudy" || value.TemperatureF == nil || *value.TemperatureF != 74 {
 		t.Fatalf("CurrentConditions = %#v, want current condition facts", value)
 	}
+	if value.WindDirection != "S" {
+		t.Fatalf("WindDirection = %q, want S", value.WindDirection)
+	}
 	data, err := json.Marshal(output.Value)
 	if err != nil {
 		t.Fatalf("Marshal current conditions: %v", err)
 	}
 	jsonText := string(data)
-	for _, field := range []string{"condition_text", "temperature_f", "apparent_temperature_f", "relative_humidity_percent", "wind_speed_mph"} {
+	for _, field := range []string{"condition_text", "temperature_f", "apparent_temperature_f", "relative_humidity_percent", "wind_speed_mph", "wind_direction"} {
 		if !strings.Contains(jsonText, field) {
 			t.Fatalf("current json = %s, want field %s", jsonText, field)
 		}
 	}
+	if strings.Contains(jsonText, "wind_direction_degrees") {
+		t.Fatalf("current json = %s, want compass wind_direction without degrees field", jsonText)
+	}
 }

 func TestAlertDigestDistinguishesCheckedEmptyAndMissing(t *testing.T) {
@@ -177,11 +247,13 @@ func TestBaseModulesOmitMissingOptionalOutputs(t *testing.T) {
 	ctx := testModuleContext()
 	ctx.Collected.Current = nil
 	ctx.Collected.Narrative = nil
+	ctx.Collected.Hourly = nil
 	ctx.Derived.ValidPeriodNarrativePeriods = nil
+	ctx.Derived.ValidPeriodHourlyPeriods = nil
 	ctx.Collected.Discussion = nil
 	ctx.Collected.WeatherStory = nil

-	for _, id := range []module.ID{module.CurrentConditions, module.NarrativeForecast, module.AreaForecastDiscussion, module.WeatherStory} {
+	for _, id := range []module.ID{module.CurrentConditions, module.NarrativeForecast, module.HourlyForecast, module.AreaForecastDiscussion, module.WeatherStory} {
 		output, err := registry.BuildModule(ctx, module.ConfigItem{ID: id})
 		if err != nil {
 			t.Fatalf("BuildModule(%s) error = %v", id, err)
@@ -263,6 +335,11 @@ func testModuleContext() ModuleContext {
 	narrativeTempF := 81.0
 	narrativePop := 60.0
 	narrativeWind := 12.0
+	narrativeWindDirection := 45.0
+	hourlyTempF := 76.0
+	hourlyPop := 70.0
+	hourlyHumidity := 66.0
+	hourlyWindMph := 14.0
 	updatedAt := mustParseModuleTime("2026-05-29T07:30:00-05:00")
 	return ModuleContext{
 		Resolved: resolved,
@@ -291,10 +368,35 @@ func testModuleContext() ModuleContext {
 						TextDescription:                   "Morning storms, then partly sunny.",
 						TemperatureF:                      floatPtr(narrativeTempF),
 						WindSpeedMph:                      &narrativeWind,
+						WindDirectionDegrees:              &narrativeWindDirection,
 						ProbabilityOfPrecipitationPercent: &narrativePop,
 					},
 				},
 			},
+			Hourly: &weatherdata.ForecastRun{
+				LocationID:   "test-grid",
+				LocationName: "Testville",
+				IssuedAt:     mustParseModuleTime("2026-05-29T10:30:00-05:00"),
+				UpdatedAt:    &updatedAt,
+				Product:      "hourly",
+				Periods: []weatherdata.ForecastPeriod{
+					{
+						StartTime:                         mustParseModuleTime("2026-05-29T08:00:00-05:00"),
+						EndTime:                           mustParseModuleTime("2026-05-29T09:00:00-05:00"),
+						TextDescription:                   "Showers likely.",
+						TemperatureF:                      &hourlyTempF,
+						WindSpeedMph:                      &hourlyWindMph,
+						WindDirectionDegrees:              &windDirection,
+						ProbabilityOfPrecipitationPercent: &hourlyPop,
+						RelativeHumidityPercent:           &hourlyHumidity,
+					},
+					{
+						StartTime:       mustParseModuleTime("2026-05-30T08:00:00-05:00"),
+						EndTime:         mustParseModuleTime("2026-05-30T09:00:00-05:00"),
+						TextDescription: "Tomorrow showers.",
+					},
+				},
+			},
 			Alerts: &weatherdata.AlertRun{Alerts: []json.RawMessage{
 				json.RawMessage(`{"event":"Flood Watch","headline":"Flooding possible","severity":"Moderate"}`),
 			}},
@@ -327,6 +429,18 @@ func testModuleContext() ModuleContext {
 			}},
 		},
 		Derived: facts.DerivedFacts{
+			ValidPeriodHourlyPeriods: []weatherdata.ForecastPeriod{
+				{
+					StartTime:                         mustParseModuleTime("2026-05-29T08:00:00-05:00"),
+					EndTime:                           mustParseModuleTime("2026-05-29T09:00:00-05:00"),
+					TextDescription:                   "Showers likely.",
+					TemperatureF:                      &hourlyTempF,
+					WindSpeedMph:                      &hourlyWindMph,
+					WindDirectionDegrees:              &windDirection,
+					ProbabilityOfPrecipitationPercent: &hourlyPop,
+					RelativeHumidityPercent:           &hourlyHumidity,
+				},
+			},
 			ValidPeriodNarrativePeriods: []weatherdata.ForecastPeriod{
 				{
 					Name:                              "Today",
@@ -336,6 +450,7 @@ func testModuleContext() ModuleContext {
 					TextDescription:                   "Morning storms, then partly sunny.",
 					TemperatureF:                      floatPtr(narrativeTempF),
 					WindSpeedMph:                      &narrativeWind,
+					WindDirectionDegrees:              &narrativeWindDirection,
 					ProbabilityOfPrecipitationPercent: &narrativePop,
 				},
 			},
--- a/internal/briefing/current_conditions_module.go
+++ b/internal/briefing/current_conditions_module.go
@@ -14,7 +14,7 @@ type CurrentConditionsModule struct {
 	RelativeHumidityPercent *float64 `json:"relative_humidity_percent,omitempty"`
 	WindSpeedKmh            *float64 `json:"wind_speed_kmh,omitempty"`
 	WindSpeedMph            *float64 `json:"wind_speed_mph,omitempty"`
-	WindDirectionDegrees    *float64 `json:"wind_direction_degrees,omitempty"`
+	WindDirection           string   `json:"wind_direction,omitempty"`
 }

 func buildCurrentConditionsModule(ctx ModuleContext, _ any) (*module.Output, error) {
@@ -34,7 +34,7 @@ func buildCurrentConditionsModule(ctx ModuleContext, _ any) (*module.Output, err
 		RelativeHumidityPercent: copyFloat(current.RelativeHumidityPercent),
 		WindSpeedKmh:            copyFloat(current.WindSpeedKmh),
 		WindSpeedMph:            copyFloat(current.WindSpeedMph),
-		WindDirectionDegrees:    copyFloat(current.WindDirectionDegrees),
+		WindDirection:           windDirectionLabel(current.WindDirectionDegrees),
 	}
 	if value.isEmpty() {
 		return nil, nil
@@ -54,5 +54,5 @@ func (v CurrentConditionsModule) isEmpty() bool {
 		v.RelativeHumidityPercent == nil &&
 		v.WindSpeedKmh == nil &&
 		v.WindSpeedMph == nil &&
-		v.WindDirectionDegrees == nil
+		v.WindDirection == ""
 }
--- a/internal/briefing/derived_daily_summary_module.go
+++ b/internal/briefing/derived_daily_summary_module.go
@@ -5,17 +5,15 @@ import (

 	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
 )

 type DerivedDailySummaryModule struct {
 	Date                          string   `json:"date,omitempty"`
 	HighTempF                     *int     `json:"high_temp_f,omitempty"`
 	LowTempF                      *int     `json:"low_temp_f,omitempty"`
-	MaxPopPercent      *int     `json:"max_pop_percent,omitempty"`
-	MaxPopWindow       string   `json:"max_pop_window,omitempty"`
-	FirstPrecipHour    string   `json:"first_precip_hour,omitempty"`
-	LastPrecipHour     string   `json:"last_precip_hour,omitempty"`
+	DailyPrecipitationProbability *int     `json:"daily_precipitation_probability,omitempty"`
+	MostLikelyPrecipitationHour   string   `json:"most_likely_precipitation_hour,omitempty"`
 	ThunderMentioned              bool     `json:"thunder_mentioned"`
 	MaxWindGustMph                *int     `json:"max_wind_gust_mph,omitempty"`
 	HeatIndexMaxF                 *int     `json:"heat_index_max_f,omitempty"`
@@ -37,7 +35,7 @@ func buildDerivedDailySummaryModule(ctx ModuleContext, _ any) (*module.Output, e

 func derivedDailySummaryValue(summary forecast.DailySummary, timing forecast.PrecipTiming, timezone string) (DerivedDailySummaryModule, error) {
 	value := DerivedDailySummaryModule{
-		Date:             summary.Date,
+		Date:             friendlyDateLabel(summary.Date, timezone),
 		ThunderMentioned: timing.ThunderMentioned,
 	}
 	conditions := map[string]struct{}{}
@@ -46,17 +44,10 @@ func derivedDailySummaryValue(summary forecast.DailySummary, timing forecast.Pre
 	var apparent forecast.Range
 	var maxPop *forecast.TimedValue
 	var maxGust *forecast.TimedValue
-	var maxPopWindow timeutil.Period
 	for _, daypart := range summary.Dayparts {
 		addRange(&temperature, daypart.Temperature)
 		addRange(&apparent, daypart.ApparentTemperature)
-		if daypart.MaxPrecipitationProbability != nil {
-			if maxPop == nil || daypart.MaxPrecipitationProbability.Value > maxPop.Value {
-				copied := *daypart.MaxPrecipitationProbability
-				maxPop = &copied
-				maxPopWindow = daypart.Period
-			}
-		}
+		maxTimedValue(&maxPop, daypart.MaxPrecipitationProbability)
 		maxTimedValue(&maxGust, daypart.PeakWindGust)
 		if daypart.DominantCondition != "" {
 			conditions[daypart.DominantCondition] = struct{}{}
@@ -70,19 +61,93 @@ func derivedDailySummaryValue(summary forecast.DailySummary, timing forecast.Pre
 			hazards[alert.Event] = struct{}{}
 		}
 	}
+	narrativeTemperature := narrativeTemperatureRange(summary.NarrativePeriods)
+	if narrativeTemperature.Max != nil {
+		value.HighTempF = roundedInt(narrativeTemperature.Max)
+	} else {
 		value.HighTempF = roundedInt(temperature.Max)
+	}
+	if narrativeTemperature.Min != nil {
+		value.LowTempF = roundedInt(narrativeTemperature.Min)
+	} else {
 		value.LowTempF = roundedInt(temperature.Min)
+	}
 	value.HeatIndexMaxF = roundedInt(apparent.Max)
+	narrativePrecipitation := narrativeMaxPrecipitation(summary.NarrativePeriods)
+	if narrativePrecipitation != nil {
+		value.DailyPrecipitationProbability = roundedInt(&narrativePrecipitation.Value)
+	} else if maxPop != nil {
+		value.DailyPrecipitationProbability = roundedInt(&maxPop.Value)
+	}
 	if maxPop != nil {
-		value.MaxPopPercent = roundedInt(&maxPop.Value)
-		value.MaxPopWindow = periodClockLabel(maxPopWindow, timezone)
+		value.MostLikelyPrecipitationHour = mostLikelyPrecipitationHour(maxPop, timezone)
 	}
 	if maxGust != nil {
 		value.MaxWindGustMph = roundedInt(&maxGust.Value)
 	}
-	value.FirstPrecipHour = timedClockLabel(timing.FirstPrecipitation, timezone)
-	value.LastPrecipHour = timedClockLabel(timing.LastPrecipitation, timezone)
 	value.DominantConditions = sortedSet(conditions)
 	value.Hazards = sortedSet(hazards)
 	return value, nil
 }
+
+func narrativeTemperatureRange(periods []weatherdata.ForecastPeriod) forecast.Range {
+	var out forecast.Range
+	for _, period := range periods {
+		addNarrativeHigh(&out, period.TemperatureFMax)
+		addNarrativeLow(&out, period.TemperatureFMin)
+		if period.TemperatureF != nil && period.IsDay != nil {
+			if *period.IsDay {
+				addNarrativeHigh(&out, period.TemperatureF)
+			} else {
+				addNarrativeLow(&out, period.TemperatureF)
+			}
+		}
+	}
+	return out
+}
+
+func addNarrativeHigh(target *forecast.Range, value *float64) {
+	if value == nil {
+		return
+	}
+	if target.Max == nil || *value > *target.Max {
+		copied := *value
+		target.Max = &copied
+	}
+}
+
+func addNarrativeLow(target *forecast.Range, value *float64) {
+	if value == nil {
+		return
+	}
+	if target.Min == nil || *value < *target.Min {
+		copied := *value
+		target.Min = &copied
+	}
+}
+
+func narrativeMaxPrecipitation(periods []weatherdata.ForecastPeriod) *forecast.TimedValue {
+	var maxPop *forecast.TimedValue
+	for _, period := range periods {
+		if period.ProbabilityOfPrecipitationPercent == nil {
+			continue
+		}
+		value := forecast.TimedValue{
+			Value: *period.ProbabilityOfPrecipitationPercent,
+			Time:  period.StartTime,
+		}
+		maxTimedValue(&maxPop, &value)
+	}
+	return maxPop
+}
+
+func mostLikelyPrecipitationHour(maxPop *forecast.TimedValue, timezone string) string {
+	if maxPop == nil || maxPop.Value <= 0 {
+		return ""
+	}
+	percent := roundedInt(&maxPop.Value)
+	if percent == nil {
+		return ""
+	}
+	return fmt.Sprintf("%d%% at %s", *percent, clockLabel(maxPop.Time, timezone))
+}
--- a/internal/briefing/derived_daypart_summaries_module.go
+++ b/internal/briefing/derived_daypart_summaries_module.go
@@ -11,7 +11,8 @@ import (
 )

 type DerivedDaypartSummaryModule struct {
-	Period             timeutil.Period `json:"period"`
+	Date               string   `json:"date,omitempty"`
+	Period             string   `json:"period,omitempty"`
 	TempRangeF         string   `json:"temp_range_f,omitempty"`
 	ApparentTempRangeF string   `json:"apparent_temp_range_f,omitempty"`
 	MaxPopPercent      *int     `json:"max_pop_percent,omitempty"`
@@ -44,7 +45,8 @@ func buildDerivedDaypartSummariesModule(ctx ModuleContext, _ any) (*module.Outpu

 func derivedDaypartSummaryValue(daypart forecast.DaypartSummary, timezone string) DerivedDaypartSummaryModule {
 	value := DerivedDaypartSummaryModule{
-		Period:             daypart.Period,
+		Date:               localDateLabel(daypart.Period.Start, timezone),
+		Period:             friendlyPeriodLabel(daypart.Period, timezone),
 		TempRangeF:         rangeLabel(daypart.Temperature),
 		ApparentTempRangeF: daypartApparentRangeLabel(daypart.ApparentTemperature),
 		DominantCondition:  daypart.DominantCondition,
--- a/internal/briefing/derived_modules_test.go
+++ b/internal/briefing/derived_modules_test.go
@@ -24,14 +24,20 @@ func TestDerivedDailySummaryModulePackagesOrdinaryForecast(t *testing.T) {
 	}
 	value := moduleValue[DerivedDailySummaryModule](t, output)

-	if value.HighTempF == nil || *value.HighTempF != 96 || value.LowTempF == nil || *value.LowTempF != 31 {
-		t.Fatalf("daily temperatures = %#v/%#v, want 96/31", value.HighTempF, value.LowTempF)
+	if value.Date != "Friday, May 29, 2026" {
+		t.Fatalf("Date = %q, want friendly local date", value.Date)
 	}
-	if value.MaxPopPercent == nil || *value.MaxPopPercent != 80 || value.MaxPopWindow != "12 PM-6 PM" {
-		t.Fatalf("max precip = %#v %q, want 80 and afternoon window", value.MaxPopPercent, value.MaxPopWindow)
+	if value.HighTempF == nil || *value.HighTempF != 88 || value.LowTempF == nil || *value.LowTempF != 64 {
+		t.Fatalf("daily temperatures = %#v/%#v, want narrative 88/64", value.HighTempF, value.LowTempF)
 	}
-	if value.FirstPrecipHour != "8 AM" || value.LastPrecipHour != "1 PM" || !value.ThunderMentioned {
-		t.Fatalf("precip timing = %#v, want morning through afternoon thunder", value)
+	if value.DailyPrecipitationProbability == nil || *value.DailyPrecipitationProbability != 55 {
+		t.Fatalf("DailyPrecipitationProbability = %#v, want narrative 55", value.DailyPrecipitationProbability)
+	}
+	if value.MostLikelyPrecipitationHour != "80% at 12 PM" || !value.ThunderMentioned {
+		t.Fatalf("precip timing = %#v, want most likely hour and thunder", value)
+	}
+	if !containsString(value.DominantConditions, "Thunderstorms with gusty wind") || containsString(value.DominantConditions, "Morning storms, then partly sunny.") {
+		t.Fatalf("DominantConditions = %#v, want daypart conditions rather than narrative conditions", value.DominantConditions)
 	}
 	if value.MaxWindGustMph == nil || *value.MaxWindGustMph != 42 {
 		t.Fatalf("MaxWindGustMph = %#v, want 42", value.MaxWindGustMph)
@@ -44,16 +50,43 @@ func TestDerivedDailySummaryModulePackagesOrdinaryForecast(t *testing.T) {
 		t.Fatalf("marshal daily summary: %v", err)
 	}
 	jsonText := string(data)
-	for _, field := range []string{"high_temp_f", "low_temp_f", "max_pop_percent", "first_precip_hour", "heat_index_max_f"} {
+	for _, field := range []string{"high_temp_f", "low_temp_f", "daily_precipitation_probability", "most_likely_precipitation_hour", "heat_index_max_f"} {
 		if !strings.Contains(jsonText, field) {
 			t.Fatalf("daily json = %s, want field %s", jsonText, field)
 		}
 	}
+	for _, removed := range []string{"max_pop_percent", "max_pop_window", "first_precip_hour", "last_precip_hour"} {
+		if strings.Contains(jsonText, removed) {
+			t.Fatalf("daily json = %s, want removed field %s omitted", jsonText, removed)
+		}
+	}
 	if strings.Contains(jsonText, "qpf") {
 		t.Fatalf("daily json = %s, want no QPF fields without upstream QPF facts", jsonText)
 	}
 }

+func TestDerivedDailySummaryModuleFallsBackWithoutNarrativeFacts(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := derivedModuleContext(report.DailyToday)
+	ctx.Derived.DailySummaries[0].NarrativePeriods = nil
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DerivedDailySummary})
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	value := moduleValue[DerivedDailySummaryModule](t, output)
+
+	if value.HighTempF == nil || *value.HighTempF != 96 || value.LowTempF == nil || *value.LowTempF != 31 {
+		t.Fatalf("daily temperatures = %#v/%#v, want fallback 96/31", value.HighTempF, value.LowTempF)
+	}
+	if value.DailyPrecipitationProbability == nil || *value.DailyPrecipitationProbability != 80 {
+		t.Fatalf("DailyPrecipitationProbability = %#v, want hourly fallback 80", value.DailyPrecipitationProbability)
+	}
+	if len(value.DominantConditions) == 0 || !containsString(value.DominantConditions, "Thunderstorms with gusty wind") {
+		t.Fatalf("DominantConditions = %#v, want fallback daypart conditions", value.DominantConditions)
+	}
+}
+
 func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := derivedModuleContext(report.DailyToday)
@@ -63,8 +96,27 @@ func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {
 		t.Fatalf("BuildModule(rainy) error = %v", err)
 	}
 	rainy := moduleValue[PrecipTimingModule](t, output)
-	if rainy.MaxPopPercent == nil || *rainy.MaxPopPercent != 80 || rainy.FirstPrecipHour != "8 AM" || rainy.LastPrecipHour != "1 PM" || !rainy.ThunderMentioned {
-		t.Fatalf("rainy precip timing = %#v, want peak, first/last, thunder", rainy)
+	if rainy.MaxPopPercent == nil || *rainy.MaxPopPercent != 80 || rainy.MaxPopTime != "12 PM" || rainy.ProbabilityThreshold != forecast.DefaultPrecipWindowProbabilityThreshold || !rainy.ThunderMentioned {
+		t.Fatalf("rainy precip timing = %#v, want peak, threshold, and thunder", rainy)
+	}
+	if len(rainy.PrecipitationWindows) != 2 {
+		t.Fatalf("rainy precipitation windows = %#v, want two windows", rainy.PrecipitationWindows)
+	}
+	if rainy.PrecipitationWindows[0].Start != "8 AM" || rainy.PrecipitationWindows[0].End != "9 AM" || rainy.PrecipitationWindows[0].MaxPopPercent == nil || *rainy.PrecipitationWindows[0].MaxPopPercent != 60 {
+		t.Fatalf("first precipitation window = %#v, want 8-9 AM at 60%%", rainy.PrecipitationWindows[0])
+	}
+	if rainy.PrecipitationWindows[1].Start != "12 PM" || rainy.PrecipitationWindows[1].End != "2 PM" || rainy.PrecipitationWindows[1].MaxPopPercent == nil || *rainy.PrecipitationWindows[1].MaxPopPercent != 80 {
+		t.Fatalf("second precipitation window = %#v, want noon-2 PM at 80%%", rainy.PrecipitationWindows[1])
+	}
+	data, err := json.Marshal(output.Value)
+	if err != nil {
+		t.Fatalf("marshal precip timing: %v", err)
+	}
+	if !strings.Contains(string(data), "precipitation_windows") || !strings.Contains(string(data), "probability_threshold") {
+		t.Fatalf("precip timing json = %s, want threshold and windows", string(data))
+	}
+	if strings.Contains(string(data), "first_precip_hour") || strings.Contains(string(data), "last_precip_hour") {
+		t.Fatalf("precip timing json = %s, want no ambiguous first/last fields", string(data))
 	}

 	ctx.Derived.PrecipTiming = forecast.BuildPrecipTiming([]weatherdata.ForecastPeriod{derivedHour("2026-05-29T10:00:00-05:00", "Sunny", 0, 70, nil, 5)})
@@ -73,8 +125,8 @@ func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {
 		t.Fatalf("BuildModule(dry) error = %v", err)
 	}
 	dry := moduleValue[PrecipTimingModule](t, output)
-	if dry.FirstPrecipHour != "" || dry.LastPrecipHour != "" || dry.ThunderMentioned {
-		t.Fatalf("dry precip timing = %#v, want no precip hours and no thunder", dry)
+	if len(dry.PrecipitationWindows) != 0 || dry.ThunderMentioned {
+		t.Fatalf("dry precip timing = %#v, want no precip windows and no thunder", dry)
 	}
 	if dry.MaxPopPercent == nil || *dry.MaxPopPercent != 0 {
 		t.Fatalf("dry MaxPopPercent = %#v, want checked zero", dry.MaxPopPercent)
@@ -98,6 +150,9 @@ func TestDerivedDaypartSummariesExposeConfiguredKeysAndHazards(t *testing.T) {
 	if morning.TempRangeF != "58" || morning.MaxPopPercent == nil || *morning.MaxPopPercent != 60 {
 		t.Fatalf("morning = %#v, want temp range and precip peak", morning)
 	}
+	if morning.Date != "2026-05-29" || morning.Period != "2026-05-29 at 6:00 AM to 2026-05-29 at 12:00 PM" {
+		t.Fatalf("morning period = %q/%q, want friendly local date and period labels", morning.Date, morning.Period)
+	}
 	afternoon := value["afternoon"]
 	if !afternoon.Heat || !afternoon.Wind || afternoon.MaxWindGustMph == nil || *afternoon.MaxWindGustMph != 42 {
 		t.Fatalf("afternoon = %#v, want heat and wind hazard values", afternoon)
@@ -111,11 +166,14 @@ func TestDerivedDaypartSummariesExposeConfiguredKeysAndHazards(t *testing.T) {
 		t.Fatalf("marshal daypart summaries: %v", err)
 	}
 	jsonText := string(data)
-	for _, field := range []string{"temp_range_f", "max_pop_percent", "max_wind_gust_mph", "dominant_condition"} {
+	for _, field := range []string{"date", "period", "temp_range_f", "max_pop_percent", "max_wind_gust_mph", "dominant_condition"} {
 		if !strings.Contains(jsonText, field) {
 			t.Fatalf("daypart json = %s, want field %s", jsonText, field)
 		}
 	}
+	if strings.Contains(jsonText, `"period":{"start"`) || strings.Contains(jsonText, `T06:00:00`) {
+		t.Fatalf("daypart json = %s, want friendly period label instead of raw timestamps", jsonText)
+	}
 }

 func TestOutdoorWindowsAndTomorrowPlanningModulesPreserveDailyContent(t *testing.T) {
@@ -191,19 +249,33 @@ func derivedModuleContext(id report.ID) ModuleContext {
 	hours := []weatherdata.ForecastPeriod{
 		derivedHour("2026-05-29T00:00:00-05:00", "Clear and cold", 0, 31, nil, 5),
 		derivedHour("2026-05-29T08:00:00-05:00", "Showers", 60, 58, nil, 15),
+		derivedHour("2026-05-29T09:00:00-05:00", "Dry break", 20, 62, nil, 10),
 		derivedHour("2026-05-29T12:00:00-05:00", "Thunderstorms with gusty wind", 80, 96, floatPtr(101), 42),
 		derivedHour("2026-05-29T13:00:00-05:00", "Heavy rain", 70, 82, nil, 30),
+		derivedHour("2026-05-29T14:00:00-05:00", "Drying out", 20, 78, nil, 12),
 	}
 	narrative := []weatherdata.ForecastPeriod{
 		{
 			Name:                              "Today",
 			StartTime:                         mustParseModuleTime("2026-05-29T06:00:00-05:00"),
 			EndTime:                           mustParseModuleTime("2026-05-29T18:00:00-05:00"),
+			IsDay:                             boolPtr(true),
 			TextDescription:                   "Morning storms, then partly sunny.",
-			TemperatureF:    floatPtr(81),
+			TemperatureFMax:                   floatPtr(88),
+			ProbabilityOfPrecipitationPercent: floatPtr(55),
+		},
+		{
+			Name:                              "Tonight",
+			StartTime:                         mustParseModuleTime("2026-05-29T18:00:00-05:00"),
+			EndTime:                           mustParseModuleTime("2026-05-30T00:00:00-05:00"),
+			IsDay:                             boolPtr(false),
+			TextDescription:                   "Clouds linger tonight.",
+			TemperatureFMin:                   floatPtr(64),
+			ProbabilityOfPrecipitationPercent: floatPtr(30),
 		},
 	}
 	summary.Dayparts[2].AlertOverlaps = []forecast.AlertOverlap{{Event: "Severe Thunderstorm Watch"}}
+	summary.NarrativePeriods = append([]weatherdata.ForecastPeriod(nil), narrative...)
 	return ModuleContext{
 		Resolved: report.Resolved{
 			Definition:  definition,
@@ -255,3 +327,16 @@ func derivedHour(start string, text string, precip float64, temperature float64,
 func floatPtr(value float64) *float64 {
 	return &value
 }
+
+func boolPtr(value bool) *bool {
+	return &value
+}
+
+func containsString(values []string, want string) bool {
+	for _, value := range values {
+		if value == want {
+			return true
+		}
+	}
+	return false
+}
--- a/internal/briefing/hourly_forecast_module.go
+++ b/internal/briefing/hourly_forecast_module.go
@@ -0,0 +1,123 @@
+package briefing
+
+import (
+	"time"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
+)
+
+type HourlyForecastModule struct {
+	Product          string                 `json:"product,omitempty"`
+	IssuedAt         time.Time              `json:"issued_at,omitempty"`
+	UpdatedAt        *time.Time             `json:"updated_at,omitempty"`
+	SourceLocation   string                 `json:"source_location,omitempty"`
+	SourceLocationID string                 `json:"source_location_id,omitempty"`
+	Periods          []HourlyForecastPeriod `json:"periods,omitempty"`
+}
+
+type HourlyForecastPeriod struct {
+	StartTime                         string   `json:"start_time,omitempty"`
+	EndTime                           string   `json:"end_time,omitempty"`
+	Name                              string   `json:"name,omitempty"`
+	IsDay                             *bool    `json:"is_day,omitempty"`
+	ConditionCode                     *int     `json:"condition_code,omitempty"`
+	TextDescription                   string   `json:"text_description,omitempty"`
+	TemperatureC                      *float64 `json:"temperature_c,omitempty"`
+	TemperatureF                      *float64 `json:"temperature_f,omitempty"`
+	TemperatureCMin                   *float64 `json:"temperature_c_min,omitempty"`
+	TemperatureFMin                   *float64 `json:"temperature_f_min,omitempty"`
+	TemperatureCMax                   *float64 `json:"temperature_c_max,omitempty"`
+	TemperatureFMax                   *float64 `json:"temperature_f_max,omitempty"`
+	DewpointC                         *float64 `json:"dewpoint_c,omitempty"`
+	DewpointF                         *float64 `json:"dewpoint_f,omitempty"`
+	WindSpeedKmh                      *float64 `json:"wind_speed_kmh,omitempty"`
+	WindSpeedMph                      *float64 `json:"wind_speed_mph,omitempty"`
+	WindGustKmh                       *float64 `json:"wind_gust_kmh,omitempty"`
+	WindGustMph                       *float64 `json:"wind_gust_mph,omitempty"`
+	WindDirection                     string   `json:"wind_direction,omitempty"`
+	BarometricPressurePa              *float64 `json:"barometric_pressure_pa,omitempty"`
+	BarometricPressureInHg            *float64 `json:"barometric_pressure_in_hg,omitempty"`
+	VisibilityMeters                  *float64 `json:"visibility_meters,omitempty"`
+	VisibilityMiles                   *float64 `json:"visibility_miles,omitempty"`
+	ApparentTemperatureC              *float64 `json:"apparent_temperature_c,omitempty"`
+	ApparentTemperatureF              *float64 `json:"apparent_temperature_f,omitempty"`
+	CloudCoverPercent                 *float64 `json:"cloud_cover_percent,omitempty"`
+	ProbabilityOfPrecipitationPercent *float64 `json:"probability_of_precipitation_percent,omitempty"`
+	PrecipitationAmountMm             *float64 `json:"precipitation_amount_mm,omitempty"`
+	PrecipitationAmountIn             *float64 `json:"precipitation_amount_in,omitempty"`
+	SnowfallDepthMM                   *float64 `json:"snowfall_depth_mm,omitempty"`
+	SnowfallDepthIn                   *float64 `json:"snowfall_depth_in,omitempty"`
+	UVIndex                           *float64 `json:"uv_index,omitempty"`
+	RelativeHumidityPercent           *float64 `json:"relative_humidity_percent,omitempty"`
+}
+
+func buildHourlyForecastModule(ctx ModuleContext, _ any) (*module.Output, error) {
+	hourly := ctx.Collected.Hourly
+	if hourly == nil || len(ctx.Derived.ValidPeriodHourlyPeriods) == 0 {
+		return nil, nil
+	}
+	value := HourlyForecastModule{
+		Product:          hourly.Product,
+		IssuedAt:         hourly.IssuedAt,
+		UpdatedAt:        copyTime(hourly.UpdatedAt),
+		SourceLocation:   hourly.LocationName,
+		SourceLocationID: hourly.LocationID,
+		Periods:          hourlyForecastPeriods(ctx.Derived.ValidPeriodHourlyPeriods, ctx.Timezone),
+	}
+	if value.isEmpty() {
+		return nil, nil
+	}
+	return &module.Output{ID: module.HourlyForecast, StanzaName: "hourly_forecast", Value: value}, nil
+}
+
+func hourlyForecastPeriods(periods []weatherdata.ForecastPeriod, timezone string) []HourlyForecastPeriod {
+	out := make([]HourlyForecastPeriod, 0, len(periods))
+	for _, period := range periods {
+		out = append(out, HourlyForecastPeriod{
+			StartTime:                         friendlyDateTimeLabel(period.StartTime, timezone),
+			EndTime:                           friendlyDateTimeLabel(period.EndTime, timezone),
+			Name:                              period.Name,
+			IsDay:                             copyBool(period.IsDay),
+			ConditionCode:                     copyInt(period.ConditionCode),
+			TextDescription:                   period.TextDescription,
+			TemperatureC:                      copyFloat(period.TemperatureC),
+			TemperatureF:                      copyFloat(period.TemperatureF),
+			TemperatureCMin:                   copyFloat(period.TemperatureCMin),
+			TemperatureFMin:                   copyFloat(period.TemperatureFMin),
+			TemperatureCMax:                   copyFloat(period.TemperatureCMax),
+			TemperatureFMax:                   copyFloat(period.TemperatureFMax),
+			DewpointC:                         copyFloat(period.DewpointC),
+			DewpointF:                         copyFloat(period.DewpointF),
+			WindSpeedKmh:                      copyFloat(period.WindSpeedKmh),
+			WindSpeedMph:                      copyFloat(period.WindSpeedMph),
+			WindGustKmh:                       copyFloat(period.WindGustKmh),
+			WindGustMph:                       copyFloat(period.WindGustMph),
+			WindDirection:                     windDirectionLabel(period.WindDirectionDegrees),
+			BarometricPressurePa:              copyFloat(period.BarometricPressurePa),
+			BarometricPressureInHg:            copyFloat(period.BarometricPressureInHg),
+			VisibilityMeters:                  copyFloat(period.VisibilityMeters),
+			VisibilityMiles:                   copyFloat(period.VisibilityMiles),
+			ApparentTemperatureC:              copyFloat(period.ApparentTemperatureC),
+			ApparentTemperatureF:              copyFloat(period.ApparentTemperatureF),
+			CloudCoverPercent:                 copyFloat(period.CloudCoverPercent),
+			ProbabilityOfPrecipitationPercent: copyFloat(period.ProbabilityOfPrecipitationPercent),
+			PrecipitationAmountMm:             copyFloat(period.PrecipitationAmountMm),
+			PrecipitationAmountIn:             copyFloat(period.PrecipitationAmountIn),
+			SnowfallDepthMM:                   copyFloat(period.SnowfallDepthMM),
+			SnowfallDepthIn:                   copyFloat(period.SnowfallDepthIn),
+			UVIndex:                           copyFloat(period.UVIndex),
+			RelativeHumidityPercent:           copyFloat(period.RelativeHumidityPercent),
+		})
+	}
+	return out
+}
+
+func (v HourlyForecastModule) isEmpty() bool {
+	return v.Product == "" &&
+		v.IssuedAt.IsZero() &&
+		v.UpdatedAt == nil &&
+		v.SourceLocation == "" &&
+		v.SourceLocationID == "" &&
+		len(v.Periods) == 0
+}
--- a/internal/briefing/module_format_helpers.go
+++ b/internal/briefing/module_format_helpers.go
@@ -2,6 +2,7 @@ package briefing

 import (
 	"fmt"
+	"math"
 	"time"

 	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
@@ -46,6 +47,19 @@ func roundedInt(value *float64) *int {
 	return &rounded
 }

+func windDirectionLabel(degrees *float64) string {
+	if degrees == nil {
+		return ""
+	}
+	labels := []string{"N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"}
+	normalized := math.Mod(*degrees, 360)
+	if normalized < 0 {
+		normalized += 360
+	}
+	sector := int(math.Floor((normalized+11.25)/22.5)) % len(labels)
+	return labels[sector]
+}
+
 func timedClockLabel(value *forecast.TimedValue, timezone string) string {
 	if value == nil {
 		return ""
@@ -60,6 +74,47 @@ func periodClockLabel(period timeutil.Period, timezone string) string {
 	return clockLabel(period.Start, timezone) + "-" + clockLabel(period.End, timezone)
 }

+func friendlyPeriodLabel(period timeutil.Period, timezone string) string {
+	if !period.IsValid() {
+		return ""
+	}
+	return friendlyDateTimeLabel(period.Start, timezone) + " to " + friendlyDateTimeLabel(period.End, timezone)
+}
+
+func friendlyDateTimeLabel(value time.Time, timezone string) string {
+	if value.IsZero() {
+		return ""
+	}
+	location, err := timeutil.LoadLocation(timezone)
+	if err != nil {
+		location = time.UTC
+	}
+	return value.In(location).Format("2006-01-02 at 3:04 PM")
+}
+
+func friendlyDateLabel(date string, timezone string) string {
+	location, err := timeutil.LoadLocation(timezone)
+	if err != nil {
+		location = time.UTC
+	}
+	parsed, err := time.ParseInLocation(timeutil.DateLayout, date, location)
+	if err != nil {
+		return date
+	}
+	return parsed.Format("Monday, January 2, 2006")
+}
+
+func localDateLabel(value time.Time, timezone string) string {
+	if value.IsZero() {
+		return ""
+	}
+	location, err := timeutil.LoadLocation(timezone)
+	if err != nil {
+		location = time.UTC
+	}
+	return value.In(location).Format(timeutil.DateLayout)
+}
+
 func clockLabel(value time.Time, timezone string) string {
 	location, err := timeutil.LoadLocation(timezone)
 	if err != nil {
--- a/internal/briefing/module_format_helpers_test.go
+++ b/internal/briefing/module_format_helpers_test.go
@@ -0,0 +1,29 @@
+package briefing
+
+import "testing"
+
+func TestWindDirectionLabelUsesSixteenPointCompass(t *testing.T) {
+	tests := []struct {
+		name    string
+		degrees *float64
+		want    string
+	}{
+		{name: "nil", degrees: nil, want: ""},
+		{name: "north", degrees: floatPtr(0), want: "N"},
+		{name: "below first boundary", degrees: floatPtr(11.24), want: "N"},
+		{name: "at first boundary", degrees: floatPtr(11.25), want: "NNE"},
+		{name: "northeast", degrees: floatPtr(45), want: "NE"},
+		{name: "south", degrees: floatPtr(180), want: "S"},
+		{name: "wrap to north", degrees: floatPtr(348.75), want: "N"},
+		{name: "full rotation", degrees: floatPtr(360), want: "N"},
+		{name: "negative normalizes", degrees: floatPtr(-45), want: "NW"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := windDirectionLabel(tt.degrees); got != tt.want {
+				t.Fatalf("windDirectionLabel(%v) = %q, want %q", tt.degrees, got, tt.want)
+			}
+		})
+	}
+}
--- a/internal/briefing/modules.go
+++ b/internal/briefing/modules.go
@@ -154,6 +154,8 @@ func collectedFactAvailable(requirement module.FactRequirement, ctx ModuleContex
 		return ctx.Collected.Current != nil
 	case module.CollectedNarrativeForecast:
 		return ctx.Collected.Narrative != nil
+	case module.CollectedHourlyForecast:
+		return ctx.Collected.Hourly != nil
 	case module.CollectedAlerts:
 		return ctx.Collected.Alerts != nil
 	case module.CollectedDiscussion:
@@ -274,6 +276,16 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			MissingData:       module.MissingDataOmit,
 			Builder:           buildNarrativeForecastModule,
 		},
+		{
+			ID:                module.HourlyForecast,
+			StanzaName:        "hourly_forecast",
+			DefaultOptions:    module.HourlyForecastOptions{},
+			RequiredCollected: []module.FactRequirement{module.CollectedHourlyForecast},
+			RequiredDerived:   []module.FactRequirement{module.RequiresDerivedHourlyPeriods},
+			SupportedReports:  []report.ID{report.DailyToday, report.DailyTomorrow},
+			MissingData:       module.MissingDataOmit,
+			Builder:           buildHourlyForecastModule,
+		},
 		{
 			ID:               module.DerivedDailySummary,
 			StanzaName:       "derived_daily_summary",
--- a/internal/briefing/narrative_forecast_module.go
+++ b/internal/briefing/narrative_forecast_module.go
@@ -18,8 +18,8 @@ type NarrativeForecastModule struct {

 type NarrativeForecastPeriod struct {
 	Name                              string   `json:"name,omitempty"`
-	StartTime                         time.Time `json:"start_time"`
-	EndTime                           time.Time `json:"end_time"`
+	StartTime                         string   `json:"start_time,omitempty"`
+	EndTime                           string   `json:"end_time,omitempty"`
 	IsDay                             *bool    `json:"is_day,omitempty"`
 	TextDescription                   string   `json:"text_description,omitempty"`
 	TemperatureC                      *float64 `json:"temperature_c,omitempty"`
@@ -32,7 +32,7 @@ type NarrativeForecastPeriod struct {
 	WindSpeedMph                      *float64 `json:"wind_speed_mph,omitempty"`
 	WindGustKmh                       *float64 `json:"wind_gust_kmh,omitempty"`
 	WindGustMph                       *float64 `json:"wind_gust_mph,omitempty"`
-	WindDirectionDegrees              *float64  `json:"wind_direction_degrees,omitempty"`
+	WindDirection                     string   `json:"wind_direction,omitempty"`
 	ProbabilityOfPrecipitationPercent *float64 `json:"probability_of_precipitation_percent,omitempty"`
 }

@@ -47,7 +47,7 @@ func buildNarrativeForecastModule(ctx ModuleContext, _ any) (*module.Output, err
 		UpdatedAt:        copyTime(narrative.UpdatedAt),
 		SourceLocation:   narrative.LocationName,
 		SourceLocationID: narrative.LocationID,
-		Periods:          narrativeForecastPeriods(ctx.Derived.ValidPeriodNarrativePeriods),
+		Periods:          narrativeForecastPeriods(ctx.Derived.ValidPeriodNarrativePeriods, ctx.Timezone),
 	}
 	if value.isEmpty() {
 		return nil, nil
@@ -55,13 +55,13 @@ func buildNarrativeForecastModule(ctx ModuleContext, _ any) (*module.Output, err
 	return &module.Output{ID: module.NarrativeForecast, StanzaName: "narrative_forecast", Value: value}, nil
 }

-func narrativeForecastPeriods(periods []weatherdata.ForecastPeriod) []NarrativeForecastPeriod {
+func narrativeForecastPeriods(periods []weatherdata.ForecastPeriod, timezone string) []NarrativeForecastPeriod {
 	out := make([]NarrativeForecastPeriod, 0, len(periods))
 	for _, period := range periods {
 		out = append(out, NarrativeForecastPeriod{
 			Name:                              period.Name,
-			StartTime:                         period.StartTime,
-			EndTime:                           period.EndTime,
+			StartTime:                         friendlyDateTimeLabel(period.StartTime, timezone),
+			EndTime:                           friendlyDateTimeLabel(period.EndTime, timezone),
 			IsDay:                             copyBool(period.IsDay),
 			TextDescription:                   period.TextDescription,
 			TemperatureC:                      copyFloat(period.TemperatureC),
@@ -74,7 +74,7 @@ func narrativeForecastPeriods(periods []weatherdata.ForecastPeriod) []NarrativeF
 			WindSpeedMph:                      copyFloat(period.WindSpeedMph),
 			WindGustKmh:                       copyFloat(period.WindGustKmh),
 			WindGustMph:                       copyFloat(period.WindGustMph),
-			WindDirectionDegrees:              copyFloat(period.WindDirectionDegrees),
+			WindDirection:                     windDirectionLabel(period.WindDirectionDegrees),
 			ProbabilityOfPrecipitationPercent: copyFloat(period.ProbabilityOfPrecipitationPercent),
 		})
 	}
--- a/internal/briefing/package.go
+++ b/internal/briefing/package.go
@@ -96,6 +96,14 @@ func copyBool(value *bool) *bool {
 	return &copied
 }

+func copyInt(value *int) *int {
+	if value == nil {
+		return nil
+	}
+	copied := *value
+	return &copied
+}
+
 func copyFloat(value *float64) *float64 {
 	if value == nil {
 		return nil
--- a/internal/briefing/precip_timing_module.go
+++ b/internal/briefing/precip_timing_module.go
@@ -8,23 +8,42 @@ import (
 type PrecipTimingModule struct {
 	MaxPopPercent        *int                        `json:"max_pop_percent,omitempty"`
 	MaxPopTime           string                      `json:"max_pop_time,omitempty"`
-	FirstPrecipHour  string `json:"first_precip_hour,omitempty"`
-	LastPrecipHour   string `json:"last_precip_hour,omitempty"`
+	ProbabilityThreshold float64                     `json:"probability_threshold"`
+	PrecipitationWindows []PrecipitationWindowModule `json:"precipitation_windows,omitempty"`
 	ThunderMentioned     bool                        `json:"thunder_mentioned"`
 }

+type PrecipitationWindowModule struct {
+	Start         string `json:"start"`
+	End           string `json:"end,omitempty"`
+	MaxPopPercent *int   `json:"max_pop_percent,omitempty"`
+	MaxPopTime    string `json:"max_pop_time,omitempty"`
+}
+
 func buildPrecipTimingModule(ctx ModuleContext, _ any) (*module.Output, error) {
 	value := precipTimingValue(ctx.Derived.PrecipTiming, ctx.Timezone)
 	return &module.Output{ID: module.PrecipTiming, StanzaName: "precip_timing", Value: value}, nil
 }

 func precipTimingValue(timing forecast.PrecipTiming, timezone string) PrecipTimingModule {
-	value := PrecipTimingModule{ThunderMentioned: timing.ThunderMentioned}
+	value := PrecipTimingModule{
+		ProbabilityThreshold: timing.ProbabilityThreshold,
+		ThunderMentioned:     timing.ThunderMentioned,
+	}
 	if timing.MaxPrecipitationProbability != nil {
 		value.MaxPopPercent = roundedInt(&timing.MaxPrecipitationProbability.Value)
 		value.MaxPopTime = clockLabel(timing.MaxPrecipitationProbability.Time, timezone)
 	}
-	value.FirstPrecipHour = timedClockLabel(timing.FirstPrecipitation, timezone)
-	value.LastPrecipHour = timedClockLabel(timing.LastPrecipitation, timezone)
+	for _, window := range timing.PrecipitationWindows {
+		item := PrecipitationWindowModule{
+			Start: clockLabel(window.Start, timezone),
+		}
+		if window.End != nil {
+			item.End = clockLabel(*window.End, timezone)
+		}
+		item.MaxPopPercent = roundedInt(&window.MaxPrecipitationProbability.Value)
+		item.MaxPopTime = clockLabel(window.MaxPrecipitationProbability.Time, timezone)
+		value.PrecipitationWindows = append(value.PrecipitationWindows, item)
+	}
 	return value
 }
--- a/internal/changes/daily.go
+++ b/internal/changes/daily.go
@@ -10,7 +10,6 @@ import (
 	"time"

 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 )

 type Thresholds struct {
@@ -64,7 +63,7 @@ func CompareDaily(previous module.Snapshot, current module.Snapshot, thresholds
 	var changes []Change
 	changes = append(changes, compareTemperatureValues("Low", previousSummary.LowTempF, currentSummary.LowTempF, thresholds.TemperatureDegrees)...)
 	changes = append(changes, compareTemperatureValues("High", previousSummary.HighTempF, currentSummary.HighTempF, thresholds.TemperatureDegrees)...)
-	changes = append(changes, comparePrecipitationValues(previousSummary.MaxPopPercent, currentSummary.MaxPopPercent, thresholds.PrecipProbabilityPoints, "")...)
+	changes = append(changes, comparePrecipitationValues(previousSummary.DailyPrecipitationProbability, currentSummary.DailyPrecipitationProbability, thresholds.PrecipProbabilityPoints, "")...)
 	if previousHasTiming && currentHasTiming {
 		changes = append(changes, comparePrecipTiming(previousTiming.MaxPopTime, currentTiming.MaxPopTime, thresholds.PrecipTimingShiftMinutes, "")...)
 	}
@@ -79,12 +78,13 @@ type dailySummaryStanza struct {
 	Date                          string `json:"date,omitempty"`
 	HighTempF                     *int   `json:"high_temp_f,omitempty"`
 	LowTempF                      *int   `json:"low_temp_f,omitempty"`
-	MaxPopPercent  *int   `json:"max_pop_percent,omitempty"`
+	DailyPrecipitationProbability *int   `json:"daily_precipitation_probability,omitempty"`
 	MaxWindGustMph                *int   `json:"max_wind_gust_mph,omitempty"`
 }

 type daypartSummaryStanza struct {
-	Period         timeutil.Period `json:"period"`
+	Date           string `json:"date,omitempty"`
+	Period         string `json:"period,omitempty"`
 	TempRangeF     string `json:"temp_range_f,omitempty"`
 	MaxPopPercent  *int   `json:"max_pop_percent,omitempty"`
 	MaxPopTime     string `json:"max_pop_time,omitempty"`
--- a/internal/changes/daily_test.go
+++ b/internal/changes/daily_test.go
@@ -3,10 +3,8 @@ package changes
 import (
 	"strings"
 	"testing"
-	"time"

 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 )

 func TestCompareDailyNoMeaningfulChanges(t *testing.T) {
@@ -95,10 +93,10 @@ func dailySnapshot(t *testing.T, low int, high int, precip int, precipTime strin
 			Date:                          "2026-05-29",
 			HighTempF:                     &high,
 			LowTempF:                      &low,
-			MaxPopPercent: &precip,
+			DailyPrecipitationProbability: &precip,
 		}},
 		module.Output{ID: module.DerivedDaypartSummaries, StanzaName: "derived_daypart_summaries", Value: map[string]daypartSummaryStanza{
-			"morning": {Period: period("2026-05-29T06:00:00Z", "2026-05-29T10:00:00Z"), TempRangeF: "60-70", Snow: snow},
+			"morning": {Date: "2026-05-29", Period: "2026-05-29 at 6:00 AM to 2026-05-29 at 10:00 AM", TempRangeF: "60-70", Snow: snow},
 		}},
 		module.Output{ID: module.PrecipTiming, StanzaName: "precip_timing", Value: precipTimingStanza{MaxPopPercent: &precip, MaxPopTime: precipTime}},
 		module.Output{ID: module.AlertDigest, StanzaName: "alert_digest", Value: alertDigestStanza{Relevant: relevant}},
@@ -114,10 +112,6 @@ func snapshot(t *testing.T, outputs ...module.Output) module.Snapshot {
 	return snapshot
 }

-func period(start string, end string) timeutil.Period {
-	return timeutil.Period{Start: at(start), End: at(end)}
-}
-
 func testThresholds() Thresholds {
 	return Thresholds{
 		TemperatureDegrees:       5,
@@ -136,11 +130,3 @@ func countType(changes []Change, changeType string) int {
 	}
 	return count
 }
-
-func at(value string) time.Time {
-	parsed, err := time.Parse(time.RFC3339, value)
-	if err != nil {
-		panic(err)
-	}
-	return parsed
-}
--- a/internal/changes/three_day.go
+++ b/internal/changes/three_day.go
@@ -5,7 +5,6 @@ import (
 	"sort"

 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 )

 func CompareThreeDay(previous module.Snapshot, current module.Snapshot, thresholds Thresholds) ([]Change, error) {
@@ -113,10 +112,7 @@ func outlookDaysFromDayparts(dayparts map[string]daypartSummaryStanza) map[strin
 }

 func daypartDate(daypart daypartSummaryStanza) string {
-	if !daypart.Period.Start.IsZero() {
-		return daypart.Period.Start.Format(timeutil.DateLayout)
-	}
-	return ""
+	return daypart.Date
 }

 func minInt(a *int, b *int) *int {
--- a/internal/changes/three_day_test.go
+++ b/internal/changes/three_day_test.go
@@ -31,7 +31,8 @@ func outlookSnapshot(t *testing.T, date string, tempRange string, precip int, pr
 	t.Helper()
 	return snapshot(t, module.Output{ID: module.DerivedDaypartSummaries, StanzaName: "derived_daypart_summaries", Value: map[string]daypartSummaryStanza{
 		date + "_morning": {
-			Period:        period(date+"T06:00:00Z", date+"T10:00:00Z"),
+			Date:          date,
+			Period:        date + " at 6:00 AM to " + date + " at 10:00 AM",
 			TempRangeF:    tempRange,
 			MaxPopPercent: &precip,
 			MaxPopTime:    precipTime,
--- a/internal/facts/facts_test.go
+++ b/internal/facts/facts_test.go
@@ -69,6 +69,12 @@ func TestBuildDerivedDailySlicesDaypartsAndAlerts(t *testing.T) {
 	if derived.PrecipTiming.FirstPrecipitation == nil || derived.PrecipTiming.FirstPrecipitation.Time.Format(time.RFC3339) != "2026-05-29T08:00:00-05:00" {
 		t.Fatalf("PrecipTiming.FirstPrecipitation = %#v, want valid-period rain start", derived.PrecipTiming.FirstPrecipitation)
 	}
+	if derived.PrecipTiming.LastPrecipitation == nil || derived.PrecipTiming.LastPrecipitation.Time.Format(time.RFC3339) != "2026-05-29T14:00:00-05:00" {
+		t.Fatalf("PrecipTiming.LastPrecipitation = %#v, want final closed window end", derived.PrecipTiming.LastPrecipitation)
+	}
+	if len(derived.PrecipTiming.PrecipitationWindows) != 2 {
+		t.Fatalf("PrecipitationWindows = %#v, want two threshold windows", derived.PrecipTiming.PrecipitationWindows)
+	}
 	if !derived.PrecipTiming.ThunderMentioned {
 		t.Fatal("PrecipTiming.ThunderMentioned = false, want true")
 	}
--- a/internal/forecast/derive.go
+++ b/internal/forecast/derive.go
@@ -47,6 +47,8 @@ type TimedValue struct {
 	Time  time.Time `json:"time"`
 }

+const DefaultPrecipWindowProbabilityThreshold = 40
+
 type Indicators struct {
 	Snow bool `json:"snow,omitempty"`
 	Ice  bool `json:"ice,omitempty"`
@@ -69,31 +71,98 @@ type PrecipTiming struct {
 	MaxPrecipitationProbability *TimedValue           `json:"maxPrecipitationProbability,omitempty"`
 	FirstPrecipitation          *TimedValue           `json:"firstPrecipitation,omitempty"`
 	LastPrecipitation           *TimedValue           `json:"lastPrecipitation,omitempty"`
+	ProbabilityThreshold        float64               `json:"probabilityThreshold"`
+	PrecipitationWindows        []PrecipitationWindow `json:"precipitationWindows,omitempty"`
 	ThunderMentioned            bool                  `json:"thunderMentioned,omitempty"`
 }

+type PrecipitationWindow struct {
+	Start                       time.Time  `json:"start"`
+	End                         *time.Time `json:"end,omitempty"`
+	MaxPrecipitationProbability TimedValue `json:"maxPrecipitationProbability"`
+	ProbabilityThreshold        float64    `json:"probabilityThreshold"`
+}
+
 func BuildPrecipTiming(periods []weatherdata.ForecastPeriod) PrecipTiming {
-	var timing PrecipTiming
-	for _, forecastPeriod := range periods {
-		setMaxTimedValue(&timing.MaxPrecipitationProbability, forecastPeriod.ProbabilityOfPrecipitationPercent, forecastPeriod.StartTime)
-		if forecastPeriod.ProbabilityOfPrecipitationPercent != nil && *forecastPeriod.ProbabilityOfPrecipitationPercent > 0 {
-			value := TimedValue{
-				Value: *forecastPeriod.ProbabilityOfPrecipitationPercent,
+	return buildPrecipTimingWithThreshold(periods, DefaultPrecipWindowProbabilityThreshold)
+}
+
+func buildPrecipTimingWithThreshold(periods []weatherdata.ForecastPeriod, threshold float64) PrecipTiming {
+	timing := PrecipTiming{ProbabilityThreshold: threshold}
+	sorted := append([]weatherdata.ForecastPeriod(nil), periods...)
+	sort.SliceStable(sorted, func(i int, j int) bool {
+		return sorted[i].StartTime.Before(sorted[j].StartTime)
+	})
+
+	var active *PrecipitationWindow
+	var activeLastEnd time.Time
+	closeActive := func() {
+		if active == nil {
+			return
+		}
+		end := activeLastEnd
+		active.End = &end
+		timing.PrecipitationWindows = append(timing.PrecipitationWindows, *active)
+		active = nil
+	}
+	startActive := func(forecastPeriod weatherdata.ForecastPeriod, probability float64) {
+		active = &PrecipitationWindow{
+			Start: forecastPeriod.StartTime,
+			MaxPrecipitationProbability: TimedValue{
+				Value: probability,
+				Time:  forecastPeriod.StartTime,
+			},
+			ProbabilityThreshold: threshold,
+		}
+		activeLastEnd = forecastPeriod.EndTime
+		if timing.FirstPrecipitation == nil {
+			timing.FirstPrecipitation = &TimedValue{
+				Value: probability,
 				Time:  forecastPeriod.StartTime,
 			}
-			if timing.FirstPrecipitation == nil || value.Time.Before(timing.FirstPrecipitation.Time) {
-				copied := value
-				timing.FirstPrecipitation = &copied
 		}
-			if timing.LastPrecipitation == nil || value.Time.After(timing.LastPrecipitation.Time) {
-				copied := value
-				timing.LastPrecipitation = &copied
+	}
+
+	for _, forecastPeriod := range sorted {
+		setMaxTimedValue(&timing.MaxPrecipitationProbability, forecastPeriod.ProbabilityOfPrecipitationPercent, forecastPeriod.StartTime)
+		if forecastPeriod.ProbabilityOfPrecipitationPercent == nil || *forecastPeriod.ProbabilityOfPrecipitationPercent < threshold {
+			closeActive()
+		} else {
+			probability := *forecastPeriod.ProbabilityOfPrecipitationPercent
+			if active == nil {
+				startActive(forecastPeriod, probability)
+			} else {
+				if forecastPeriod.StartTime.After(activeLastEnd) {
+					closeActive()
+					startActive(forecastPeriod, probability)
+				}
+				if probability > active.MaxPrecipitationProbability.Value {
+					active.MaxPrecipitationProbability = TimedValue{
+						Value: probability,
+						Time:  forecastPeriod.StartTime,
+					}
+				}
+				if forecastPeriod.EndTime.After(activeLastEnd) {
+					activeLastEnd = forecastPeriod.EndTime
+				}
 			}
 		}
 		if mentionsThunder(forecastPeriod.TextDescription) {
 			timing.ThunderMentioned = true
 		}
 	}
+	if active != nil {
+		timing.PrecipitationWindows = append(timing.PrecipitationWindows, *active)
+	}
+	if len(timing.PrecipitationWindows) > 0 {
+		final := timing.PrecipitationWindows[len(timing.PrecipitationWindows)-1]
+		if final.End != nil {
+			timing.LastPrecipitation = &TimedValue{
+				Value: final.MaxPrecipitationProbability.Value,
+				Time:  *final.End,
+			}
+		}
+	}
 	return timing
 }

--- a/internal/forecast/derive_test.go
+++ b/internal/forecast/derive_test.go
@@ -210,31 +210,94 @@ func TestAlertOverlap(t *testing.T) {
 	}
 }

-func TestBuildPrecipTimingTracksRainAndThunder(t *testing.T) {
+func TestBuildPrecipTimingBuildsThresholdWindows(t *testing.T) {
 	location := time.FixedZone("Test", -5*60*60)
 	periods := []weatherdata.ForecastPeriod{
 		hour(location, "2026-05-29T08:00:00-05:00", "2026-05-29T09:00:00-05:00", "Cloudy", 70, nil, ptr(0), nil, nil),
-		hour(location, "2026-05-29T09:00:00-05:00", "2026-05-29T10:00:00-05:00", "Showers", 70, nil, ptr(30), nil, nil),
 		hour(location, "2026-05-29T12:00:00-05:00", "2026-05-29T13:00:00-05:00", "Thunderstorms", 70, nil, ptr(80), nil, nil),
-		hour(location, "2026-05-29T18:00:00-05:00", "2026-05-29T19:00:00-05:00", "Dry", 70, nil, ptr(0), nil, nil),
+		hour(location, "2026-05-29T11:00:00-05:00", "2026-05-29T12:00:00-05:00", "Brief lull", 70, nil, ptr(39.999), nil, nil),
+		hour(location, "2026-05-29T13:00:00-05:00", "2026-05-29T14:00:00-05:00", "Unknown rain chance", 70, nil, nil, nil, nil),
+		hour(location, "2026-05-29T10:00:00-05:00", "2026-05-29T11:00:00-05:00", "Rain likely", 70, nil, ptr(60), nil, nil),
+		hour(location, "2026-05-29T09:00:00-05:00", "2026-05-29T10:00:00-05:00", "Showers", 70, nil, ptr(40), nil, nil),
 	}

 	timing := BuildPrecipTiming(periods)

 	if timing.FirstPrecipitation == nil || timing.FirstPrecipitation.Time.Format(time.RFC3339) != "2026-05-29T09:00:00-05:00" {
-		t.Fatalf("FirstPrecipitation = %#v, want 9 AM shower", timing.FirstPrecipitation)
+		t.Fatalf("FirstPrecipitation = %#v, want first threshold window start", timing.FirstPrecipitation)
 	}
-	if timing.LastPrecipitation == nil || timing.LastPrecipitation.Time.Format(time.RFC3339) != "2026-05-29T12:00:00-05:00" {
-		t.Fatalf("LastPrecipitation = %#v, want noon thunderstorm", timing.LastPrecipitation)
+	if timing.LastPrecipitation == nil || timing.LastPrecipitation.Time.Format(time.RFC3339) != "2026-05-29T13:00:00-05:00" {
+		t.Fatalf("LastPrecipitation = %#v, want final closed threshold window end", timing.LastPrecipitation)
 	}
 	if timing.MaxPrecipitationProbability == nil || timing.MaxPrecipitationProbability.Value != 80 {
 		t.Fatalf("MaxPrecipitationProbability = %#v, want 80", timing.MaxPrecipitationProbability)
 	}
+	if timing.ProbabilityThreshold != DefaultPrecipWindowProbabilityThreshold {
+		t.Fatalf("ProbabilityThreshold = %v, want default threshold", timing.ProbabilityThreshold)
+	}
+	if len(timing.PrecipitationWindows) != 2 {
+		t.Fatalf("PrecipitationWindows length = %d, want 2: %#v", len(timing.PrecipitationWindows), timing.PrecipitationWindows)
+	}
+	first := timing.PrecipitationWindows[0]
+	if first.Start.Format(time.RFC3339) != "2026-05-29T09:00:00-05:00" || first.End == nil || first.End.Format(time.RFC3339) != "2026-05-29T11:00:00-05:00" {
+		t.Fatalf("first window = %#v, want 9-11 AM", first)
+	}
+	if first.MaxPrecipitationProbability.Value != 60 || first.MaxPrecipitationProbability.Time.Format(time.RFC3339) != "2026-05-29T10:00:00-05:00" {
+		t.Fatalf("first window max = %#v, want 60 at 10 AM", first.MaxPrecipitationProbability)
+	}
+	second := timing.PrecipitationWindows[1]
+	if second.Start.Format(time.RFC3339) != "2026-05-29T12:00:00-05:00" || second.End == nil || second.End.Format(time.RFC3339) != "2026-05-29T13:00:00-05:00" {
+		t.Fatalf("second window = %#v, want noon-1 PM", second)
+	}
 	if !timing.ThunderMentioned {
 		t.Fatal("ThunderMentioned = false, want true")
 	}
 }

+func TestBuildPrecipTimingLeavesFinalWindowOpen(t *testing.T) {
+	location := time.FixedZone("Test", -5*60*60)
+	periods := []weatherdata.ForecastPeriod{
+		hour(location, "2026-05-29T08:00:00-05:00", "2026-05-29T09:00:00-05:00", "Cloudy", 70, nil, ptr(0), nil, nil),
+		hour(location, "2026-05-29T09:00:00-05:00", "2026-05-29T10:00:00-05:00", "Showers", 70, nil, ptr(45), nil, nil),
+		hour(location, "2026-05-29T10:00:00-05:00", "2026-05-29T11:00:00-05:00", "Rain likely", 70, nil, ptr(60), nil, nil),
+	}
+
+	timing := BuildPrecipTiming(periods)
+
+	if len(timing.PrecipitationWindows) != 1 {
+		t.Fatalf("PrecipitationWindows length = %d, want 1", len(timing.PrecipitationWindows))
+	}
+	if timing.PrecipitationWindows[0].End != nil {
+		t.Fatalf("open window End = %v, want nil", timing.PrecipitationWindows[0].End)
+	}
+	if timing.LastPrecipitation != nil {
+		t.Fatalf("LastPrecipitation = %#v, want nil for open final window", timing.LastPrecipitation)
+	}
+}
+
+func TestBuildPrecipTimingSupportsNonDefaultThreshold(t *testing.T) {
+	location := time.FixedZone("Test", -5*60*60)
+	periods := []weatherdata.ForecastPeriod{
+		hour(location, "2026-05-29T08:00:00-05:00", "2026-05-29T09:00:00-05:00", "Showers", 70, nil, ptr(50), nil, nil),
+		hour(location, "2026-05-29T09:00:00-05:00", "2026-05-29T10:00:00-05:00", "Rain likely", 70, nil, ptr(60), nil, nil),
+		hour(location, "2026-05-29T10:00:00-05:00", "2026-05-29T11:00:00-05:00", "Showers", 70, nil, ptr(55), nil, nil),
+		hour(location, "2026-05-29T11:00:00-05:00", "2026-05-29T12:00:00-05:00", "Drying out", 70, nil, ptr(20), nil, nil),
+	}
+
+	timing := buildPrecipTimingWithThreshold(periods, 55)
+
+	if timing.ProbabilityThreshold != 55 {
+		t.Fatalf("ProbabilityThreshold = %v, want 55", timing.ProbabilityThreshold)
+	}
+	if len(timing.PrecipitationWindows) != 1 {
+		t.Fatalf("PrecipitationWindows length = %d, want 1", len(timing.PrecipitationWindows))
+	}
+	window := timing.PrecipitationWindows[0]
+	if window.Start.Format(time.RFC3339) != "2026-05-29T09:00:00-05:00" || window.End == nil || window.End.Format(time.RFC3339) != "2026-05-29T11:00:00-05:00" {
+		t.Fatalf("window = %#v, want 9-11 AM", window)
+	}
+}
+
 func TestBuildPrecipTimingHandlesDryForecast(t *testing.T) {
 	location := time.FixedZone("Test", -5*60*60)
 	periods := []weatherdata.ForecastPeriod{
@@ -243,9 +306,12 @@ func TestBuildPrecipTimingHandlesDryForecast(t *testing.T) {

 	timing := BuildPrecipTiming(periods)

-	if timing.FirstPrecipitation != nil || timing.LastPrecipitation != nil || timing.ThunderMentioned {
+	if timing.FirstPrecipitation != nil || timing.LastPrecipitation != nil || len(timing.PrecipitationWindows) != 0 || timing.ThunderMentioned {
 		t.Fatalf("dry timing = %#v, want no precip timing and no thunder", timing)
 	}
+	if timing.ProbabilityThreshold != DefaultPrecipWindowProbabilityThreshold {
+		t.Fatalf("ProbabilityThreshold = %v, want default threshold", timing.ProbabilityThreshold)
+	}
 	if timing.MaxPrecipitationProbability == nil || timing.MaxPrecipitationProbability.Value != 0 {
 		t.Fatalf("dry max precip = %#v, want checked zero chance", timing.MaxPrecipitationProbability)
 	}
--- a/internal/module/module.go
+++ b/internal/module/module.go
@@ -14,6 +14,7 @@ const (
 	Metadata                ID = "metadata"
 	CurrentConditions       ID = "current_conditions"
 	NarrativeForecast       ID = "narrative_forecast"
+	HourlyForecast          ID = "hourly_forecast"
 	DerivedDailySummary     ID = "derived_daily_summary"
 	DerivedDaypartSummaries ID = "derived_daypart_summaries"
 	PrecipTiming            ID = "precip_timing"
@@ -106,6 +107,7 @@ type FactRequirement string
 const (
 	CollectedCurrentConditions      FactRequirement = "collected.current_conditions"
 	CollectedNarrativeForecast      FactRequirement = "collected.narrative_forecast"
+	CollectedHourlyForecast         FactRequirement = "collected.hourly_forecast"
 	CollectedAlerts                 FactRequirement = "collected.alerts"
 	CollectedDiscussion             FactRequirement = "collected.discussion"
 	CollectedWeatherStory           FactRequirement = "collected.weather_story"
@@ -130,6 +132,7 @@ const (
 type MetadataOptions struct{}
 type CurrentConditionsOptions struct{}
 type NarrativeForecastOptions struct{}
+type HourlyForecastOptions struct{}
 type DerivedDailySummaryOptions struct{}
 type DerivedDaypartSummariesOptions struct{}
 type PrecipTimingOptions struct{}
--- a/internal/promptinput/package.go
+++ b/internal/promptinput/package.go
@@ -18,6 +18,35 @@ import (

 const SchemaVersion = "weatherreporter.data_package.v2"

+const (
+	metadataStanza                 = "metadata"
+	categoryApplicableRiskProducts = "applicable_risk_products"
+	categoryDerivedSummaries       = "derived_summaries"
+	categoryNarrativeProducts      = "narrative_products"
+	categoryRawData                = "raw_data"
+)
+
+var briefingCategoryOrder = []string{
+	categoryApplicableRiskProducts,
+	categoryDerivedSummaries,
+	categoryNarrativeProducts,
+	categoryRawData,
+}
+
+var briefingStanzaCategories = map[string]string{
+	string(module.AlertDigest):             categoryApplicableRiskProducts,
+	string(module.DerivedDailySummary):     categoryDerivedSummaries,
+	string(module.DerivedDaypartSummaries): categoryDerivedSummaries,
+	string(module.PrecipTiming):            categoryDerivedSummaries,
+	string(module.OutdoorWindows):          categoryDerivedSummaries,
+	string(module.TomorrowPlanning):        categoryDerivedSummaries,
+	string(module.NarrativeForecast):       categoryNarrativeProducts,
+	string(module.AreaForecastDiscussion):  categoryNarrativeProducts,
+	string(module.WeatherStory):            categoryNarrativeProducts,
+	string(module.CurrentConditions):       categoryRawData,
+	string(module.HourlyForecast):          categoryRawData,
+}
+
 type BuildRequest struct {
 	Metadata      Metadata
 	Modules       module.Snapshot
@@ -144,13 +173,24 @@ func Validate(pkg Package) error {
 	if len(pkg.Briefing.Order) == 0 {
 		return fmt.Errorf("briefing stanzas are required")
 	}
+	seen := map[string]struct{}{}
 	for _, name := range pkg.Briefing.Order {
 		if name == "" {
 			return fmt.Errorf("briefing stanza name is required")
 		}
+		if _, ok := seen[name]; ok {
+			return fmt.Errorf("duplicate briefing stanza %q", name)
+		}
+		seen[name] = struct{}{}
 		if _, ok := pkg.Briefing.Values[name]; !ok {
 			return fmt.Errorf("briefing stanza %q is missing", name)
 		}
+		if name == metadataStanza {
+			continue
+		}
+		if _, ok := briefingStanzaCategories[name]; !ok {
+			return fmt.Errorf("briefing stanza %q has no prompt-input category", name)
+		}
 	}
 	return nil
 }
@@ -191,17 +231,40 @@ func LoadYAML(data []byte) (Package, error) {

 func (b BriefingStanzas) MarshalYAML() (any, error) {
 	node := &yaml.Node{Kind: yaml.MappingNode}
+	categoryNames := map[string][]string{}
 	for _, name := range b.Order {
 		value, ok := b.Values[name]
 		if !ok {
 			continue
 		}
-		keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: name}
-		valueNode, err := yamlNode(value)
-		if err != nil {
-			return nil, fmt.Errorf("marshal briefing stanza %q: %w", name, err)
+		if name == metadataStanza {
+			if err := appendYAMLMappingValue(node, name, value); err != nil {
+				return nil, err
 			}
-		node.Content = append(node.Content, keyNode, valueNode)
+			continue
+		}
+		category, ok := briefingStanzaCategories[name]
+		if !ok {
+			return nil, fmt.Errorf("briefing stanza %q has no prompt-input category", name)
+		}
+		categoryNames[category] = append(categoryNames[category], name)
+	}
+	for _, category := range briefingCategoryOrder {
+		names := categoryNames[category]
+		if len(names) == 0 {
+			continue
+		}
+		categoryNode := &yaml.Node{Kind: yaml.MappingNode}
+		for _, name := range names {
+			value := b.Values[name]
+			if err := appendYAMLMappingValue(categoryNode, name, value); err != nil {
+				return nil, err
+			}
+		}
+		node.Content = append(node.Content,
+			&yaml.Node{Kind: yaml.ScalarNode, Value: category},
+			categoryNode,
+		)
 	}
 	return node, nil
 }
@@ -212,14 +275,46 @@ func (b *BriefingStanzas) UnmarshalYAML(value *yaml.Node) error {
 	}
 	values := map[string]any{}
 	order := make([]string, 0, len(value.Content)/2)
+	seen := map[string]struct{}{}
+	seenCategories := map[string]struct{}{}
+	categoryOrder := map[string][]string{}
 	for i := 0; i < len(value.Content); i += 2 {
 		name := value.Content[i].Value
-		var stanza any
-		if err := value.Content[i+1].Decode(&stanza); err != nil {
+		if name == metadataStanza {
+			if err := decodeBriefingStanza(value.Content[i+1], name, values, &order, seen); err != nil {
 				return err
 			}
-		order = append(order, name)
-		values[name] = stanza
+			continue
+		}
+		if !knownBriefingCategory(name) {
+			return fmt.Errorf("unknown briefing category %q", name)
+		}
+		if _, ok := seenCategories[name]; ok {
+			return fmt.Errorf("duplicate briefing category %q", name)
+		}
+		seenCategories[name] = struct{}{}
+		categoryNode := value.Content[i+1]
+		if categoryNode.Kind != yaml.MappingNode {
+			return fmt.Errorf("briefing category %q must be a mapping", name)
+		}
+		var names []string
+		for j := 0; j < len(categoryNode.Content); j += 2 {
+			stanzaName := categoryNode.Content[j].Value
+			category, ok := briefingStanzaCategories[stanzaName]
+			if !ok {
+				return fmt.Errorf("briefing stanza %q has no prompt-input category", stanzaName)
+			}
+			if category != name {
+				return fmt.Errorf("briefing stanza %q belongs under category %q, not %q", stanzaName, category, name)
+			}
+			if err := decodeBriefingStanza(categoryNode.Content[j+1], stanzaName, values, &names, seen); err != nil {
+				return err
+			}
+		}
+		categoryOrder[name] = names
+	}
+	for _, category := range briefingCategoryOrder {
+		order = append(order, categoryOrder[category]...)
 	}
 	b.Order = order
 	b.Values = values
@@ -250,6 +345,39 @@ func (b *BriefingStanzas) UnmarshalJSON(data []byte) error {
 	return nil
 }

+func appendYAMLMappingValue(node *yaml.Node, name string, value any) error {
+	keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: name}
+	valueNode, err := yamlNode(value)
+	if err != nil {
+		return fmt.Errorf("marshal briefing stanza %q: %w", name, err)
+	}
+	node.Content = append(node.Content, keyNode, valueNode)
+	return nil
+}
+
+func decodeBriefingStanza(node *yaml.Node, name string, values map[string]any, order *[]string, seen map[string]struct{}) error {
+	if _, ok := seen[name]; ok {
+		return fmt.Errorf("duplicate briefing stanza %q", name)
+	}
+	var stanza any
+	if err := node.Decode(&stanza); err != nil {
+		return err
+	}
+	seen[name] = struct{}{}
+	*order = append(*order, name)
+	values[name] = stanza
+	return nil
+}
+
+func knownBriefingCategory(name string) bool {
+	for _, category := range briefingCategoryOrder {
+		if name == category {
+			return true
+		}
+	}
+	return false
+}
+
 func yamlNode(value any) (*yaml.Node, error) {
 	data, err := json.Marshal(value)
 	if err != nil {
--- a/internal/promptinput/package_test.go
+++ b/internal/promptinput/package_test.go
@@ -106,7 +106,7 @@ func TestBuildUsesNamedSnapshotStanzas(t *testing.T) {
 	req.Metadata.PromptID = "weather.three_day_outlook"
 	req.Modules = snapshotWithOutputs(t,
 		module.Output{ID: module.Metadata, StanzaName: "metadata", Value: map[string]string{"run_id": req.Metadata.RunID}},
-		module.Output{ID: module.DerivedDaypartSummaries, StanzaName: "three_day", Value: map[string]any{"days": []string{"2026-05-29"}}},
+		module.Output{ID: module.DerivedDaypartSummaries, StanzaName: "derived_daypart_summaries", Value: map[string]any{"days": []string{"2026-05-29"}}},
 	)

 	pkg, err := Build(req)
@@ -117,12 +117,12 @@ func TestBuildUsesNamedSnapshotStanzas(t *testing.T) {
 	if pkg.Report.ID != report.ThreeDay {
 		t.Fatalf("Report.ID = %q, want three_day", pkg.Report.ID)
 	}
-	if _, ok := pkg.Briefing.Values["three_day"]; !ok {
-		t.Fatal("Briefing.Values[three_day] missing")
+	if _, ok := pkg.Briefing.Values["derived_daypart_summaries"]; !ok {
+		t.Fatal("Briefing.Values[derived_daypart_summaries] missing")
 	}
 }

-func TestMarshalYAMLIsDeterministicAndUsesNamedStanzas(t *testing.T) {
+func TestMarshalYAMLIsDeterministicAndGroupsNamedStanzas(t *testing.T) {
 	pkg, err := Build(validBuildRequest(t))
 	if err != nil {
 		t.Fatalf("Build() error = %v", err)
@@ -141,9 +141,26 @@ func TestMarshalYAMLIsDeterministicAndUsesNamedStanzas(t *testing.T) {
 	}
 	if !strings.Contains(string(first), "schema_version: weatherreporter.data_package.v2") ||
 		!strings.Contains(string(first), "briefing:\n") ||
+		!strings.Contains(string(first), "  applicable_risk_products:\n") ||
+		!strings.Contains(string(first), "  derived_summaries:\n") ||
+		!strings.Contains(string(first), "  narrative_products:\n") ||
+		!strings.Contains(string(first), "  raw_data:\n") ||
 		!strings.Contains(string(first), "    current_conditions:\n") ||
 		!strings.Contains(string(first), "      condition_text: Partly cloudy") {
-		t.Fatalf("YAML output missing expected named stanzas:\n%s", string(first))
+		t.Fatalf("YAML output missing expected grouped stanzas:\n%s", string(first))
+	}
+	for _, pair := range []struct {
+		before string
+		after  string
+	}{
+		{before: "  metadata:\n", after: "  applicable_risk_products:\n"},
+		{before: "  applicable_risk_products:\n", after: "  derived_summaries:\n"},
+		{before: "  derived_summaries:\n", after: "  narrative_products:\n"},
+		{before: "  narrative_products:\n", after: "  raw_data:\n"},
+	} {
+		if strings.Index(string(first), pair.before) < 0 || strings.Index(string(first), pair.after) < 0 || strings.Index(string(first), pair.before) > strings.Index(string(first), pair.after) {
+			t.Fatalf("YAML category order is wrong, want %q before %q:\n%s", pair.before, pair.after, string(first))
+		}
 	}
 }

@@ -165,8 +182,51 @@ func TestLoadYAMLRoundTrip(t *testing.T) {
 	if loaded.SchemaVersion != SchemaVersion || loaded.RunID != pkg.RunID {
 		t.Fatalf("loaded package = %#v, want schema and run id", loaded)
 	}
-	if loaded.Briefing.Order[1] != "current_conditions" {
-		t.Fatalf("loaded package order = %#v, want current_conditions second", loaded.Briefing.Order)
+	wantOrder := []string{"metadata", "alert_digest", "derived_daily_summary", "narrative_forecast", "current_conditions"}
+	if strings.Join(loaded.Briefing.Order, ",") != strings.Join(wantOrder, ",") {
+		t.Fatalf("loaded package order = %#v, want grouped category order %#v", loaded.Briefing.Order, wantOrder)
+	}
+	if got := loaded.Briefing.Values["current_conditions"].(map[string]any)["condition_text"]; got != "Partly cloudy" {
+		t.Fatalf("loaded current_conditions.condition_text = %#v, want Partly cloudy", got)
+	}
+}
+
+func TestMarshalYAMLRejectsUncategorizedStanza(t *testing.T) {
+	req := validBuildRequest(t)
+	req.Modules = snapshotWithOutputs(t, module.Output{ID: module.ID("custom"), StanzaName: "custom", Value: map[string]string{"value": "x"}})
+
+	_, err := Build(req)
+	if err == nil || !strings.Contains(err.Error(), `briefing stanza "custom" has no prompt-input category`) {
+		t.Fatalf("Build() error = %v, want uncategorized stanza error", err)
+	}
+}
+
+func TestLoadYAMLRejectsMisplacedStanza(t *testing.T) {
+	data := []byte(`
+schema_version: weatherreporter.data_package.v2
+run_id: 20260529T100000Z_daily_today
+report:
+  id: daily_today
+  prompt_id: weather.daily_report
+  generated_at: 2026-05-29T10:00:00Z
+  timezone: America/Chicago
+  current_local_date: "2026-05-29"
+  valid_period:
+    start: 2026-05-29T05:00:00Z
+    end: 2026-05-30T05:00:00Z
+briefing:
+  metadata:
+    run_id: 20260529T100000Z_daily_today
+  raw_data:
+    alert_digest:
+      checked: true
+recent_changes:
+  items: []
+`)
+
+	_, err := LoadYAML(data)
+	if err == nil || !strings.Contains(err.Error(), `briefing stanza "alert_digest" belongs under category "applicable_risk_products"`) {
+		t.Fatalf("LoadYAML() error = %v, want misplaced stanza error", err)
 	}
 }

@@ -190,6 +250,8 @@ func validBuildRequest(t *testing.T) BuildRequest {
 			module.Output{ID: module.Metadata, StanzaName: "metadata", Value: map[string]string{"run_id": "20260529T100000Z_daily_today"}},
 			module.Output{ID: module.CurrentConditions, StanzaName: "current_conditions", Value: map[string]string{"condition_text": "Partly cloudy"}},
 			module.Output{ID: module.DerivedDailySummary, StanzaName: "derived_daily_summary", Value: map[string]string{"date": "2026-05-29"}},
+			module.Output{ID: module.AlertDigest, StanzaName: "alert_digest", Value: map[string]bool{"checked": true}},
+			module.Output{ID: module.NarrativeForecast, StanzaName: "narrative_forecast", Value: map[string]string{"product": "narrative"}},
 		),
 	}
 }
--- a/internal/report/daily_report.go
+++ b/internal/report/daily_report.go
@@ -49,13 +49,25 @@ func dailyTodayModules() []module.ConfigItem {
 		module.AreaForecastDiscussion,
 		module.WeatherStory,
 		module.OutdoorWindows,
+		module.HourlyForecast,
 	)
 }

 func dailyTomorrowModules() []module.ConfigItem {
-	items := dailyTodayModules()
-	items = append(items, module.ConfigItem{ID: module.TomorrowPlanning})
-	return items
+	return moduleItems(
+		module.Metadata,
+		module.CurrentConditions,
+		module.NarrativeForecast,
+		module.DerivedDailySummary,
+		module.DerivedDaypartSummaries,
+		module.PrecipTiming,
+		module.AlertDigest,
+		module.AreaForecastDiscussion,
+		module.WeatherStory,
+		module.OutdoorWindows,
+		module.TomorrowPlanning,
+		module.HourlyForecast,
+	)
 }

 func resolveDailyToday(req ResolveRequest) (timeutil.Period, error) {
--- a/internal/report/period_test.go
+++ b/internal/report/period_test.go
@@ -270,6 +270,7 @@ func TestRegistryDefinitionsDeclareDefaultModules(t *testing.T) {
 				module.AreaForecastDiscussion,
 				module.WeatherStory,
 				module.OutdoorWindows,
+				module.HourlyForecast,
 			},
 		},
 		{
@@ -286,6 +287,7 @@ func TestRegistryDefinitionsDeclareDefaultModules(t *testing.T) {
 				module.WeatherStory,
 				module.OutdoorWindows,
 				module.TomorrowPlanning,
+				module.HourlyForecast,
 			},
 		},
 		{
Author	SHA1	Message	Date
Eric Rakestraw	f149563c68	Refactor the yaml data package to group data sources by category	2026-06-10 11:50:22 -05:00
Eric Rakestraw	276e4f1189	Implement friendly time formatting in select modules	2026-06-10 10:36:52 -05:00
Eric Rakestraw	cb42cad6a6	Add an hourly forecast module and adjust the daily summary for consistency	2026-06-10 10:00:36 -05:00
Eric Rakestraw	ef044327c6	Refactored the derived_daily_summary module to utilize narrative forecast data where available	2026-06-10 09:35:39 -05:00
Eric Rakestraw	d1d0df11a8	Update wind direction and precipitation window presentation	2026-06-10 09:24:06 -05:00