Rename rolling report to hourly

2026-06-14 04:26:05 +00:00
parent b3f7c9c1f2
commit 8d737395dc
28 changed files with 220 additions and 600 deletions
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -30,7 +30,7 @@ type ReportKind string
 const (
 	ReportDaily    ReportKind = "daily"
 	ReportTomorrow ReportKind = "tomorrow"
-	ReportNearTerm ReportKind = "near-term"
+	ReportHourly   ReportKind = "hourly"
 	ReportThreeDay ReportKind = "three-day"
 	ReportWeekend  ReportKind = "weekend"
 	ReportStorm    ReportKind = "storm"
@@ -387,8 +387,8 @@ func reportIDForCommand(kind ReportKind) (report.ID, error) {
 		return report.DailyToday, nil
 	case ReportTomorrow:
 		return report.DailyTomorrow, nil
-	case ReportNearTerm:
-		return report.NearTerm, nil
+	case ReportHourly:
+		return report.Hourly, nil
 	case ReportThreeDay:
 		return report.ThreeDay, nil
 	case ReportWeekend:
--- a/internal/app/app_test.go
+++ b/internal/app/app_test.go
@@ -349,19 +349,19 @@ func TestGenerateReportOmitsSPCConvectiveDiscussionBelowThreshold(t *testing.T)
 	}
 }

-func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
-	server := nearTermBundleServer(t)
+func TestGenerateHourlyReportWritesExpectedArtifacts(t *testing.T) {
+	server := hourlyBundleServer(t)
 	cfg := dailyTestConfig(t, server)
 	cfg.Workspace.Root = t.TempDir()
 	resolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
-		Report: ReportNearTerm,
+		Report: ReportHourly,
 	}, mustParse("2026-05-29T08:30:00-05:00"))
 	if err != nil {
 		t.Fatalf("ResolveGenerate() error = %v", err)
 	}
-	outputPath := filepath.Join(t.TempDir(), "near-term.md")
-	renderer := successfulRenderer("# Near-Term Report\n")
+	outputPath := filepath.Join(t.TempDir(), "hourly.md")
+	renderer := successfulRenderer("# Hourly Report\n")

 	result, err := GenerateReport(context.Background(), ReportRequest{
 		Config:     cfg,
@@ -373,8 +373,8 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 		t.Fatalf("GenerateReport() error = %v", err)
 	}

-	if result.Metadata.ReportID != report.NearTerm || result.Metadata.PromptID != "weather.near_term_report" {
-		t.Fatalf("metadata report/prompt = %q/%q, want near-term", result.Metadata.ReportID, result.Metadata.PromptID)
+	if result.Metadata.ReportID != report.Hourly || result.Metadata.PromptID != "weather.hourly_report" {
+		t.Fatalf("metadata report/prompt = %q/%q, want hourly", result.Metadata.ReportID, result.Metadata.PromptID)
 	}
 	if got := result.Metadata.ValidPeriod.Start.Format(time.RFC3339); got != "2026-05-29T08:30:00-05:00" {
 		t.Fatalf("valid period start = %s, want rolling window start", got)
@@ -382,14 +382,14 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 	if got := result.Metadata.ValidPeriod.End.Format(time.RFC3339); got != "2026-05-29T14:30:00-05:00" {
 		t.Fatalf("valid period end = %s, want six-hour rolling window end", got)
 	}
-	if renderer.renderRequest.PromptID != "weather.near_term_report" || renderer.runRequest.PromptID != "weather.near_term_report" {
-		t.Fatalf("renderer prompt IDs = %q/%q, want near-term prompt", renderer.renderRequest.PromptID, renderer.runRequest.PromptID)
+	if renderer.renderRequest.PromptID != "weather.hourly_report" || renderer.runRequest.PromptID != "weather.hourly_report" {
+		t.Fatalf("renderer prompt IDs = %q/%q, want hourly prompt", renderer.renderRequest.PromptID, renderer.runRequest.PromptID)
 	}
-	if !strings.Contains(result.ReportPath, filepath.Join("reports", "near-term")) {
-		t.Fatalf("ReportPath = %q, want near-term artifact group", result.ReportPath)
+	if !strings.Contains(result.ReportPath, filepath.Join("reports", "hourly")) {
+		t.Fatalf("ReportPath = %q, want hourly artifact group", result.ReportPath)
 	}
-	if !strings.Contains(result.DataPackagePath, filepath.Join("data-packages", "near-term", "2026-05-29")) {
-		t.Fatalf("DataPackagePath = %q, want near-term artifact group", result.DataPackagePath)
+	if !strings.Contains(result.DataPackagePath, filepath.Join("data-packages", "hourly", "2026-05-29")) {
+		t.Fatalf("DataPackagePath = %q, want hourly artifact group", result.DataPackagePath)
 	}
 	assertPathsExist(t, result.ModuleSnapshotPath, result.DataPackagePath, result.PreflightPath, result.ReportPath, result.MetadataPath, outputPath)
 	if result.OutputPath != outputPath {
@@ -399,7 +399,7 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 	if err != nil {
 		t.Fatalf("read output copy: %v", err)
 	}
-	if !strings.Contains(string(copiedReport), "# Near-Term Report") {
+	if !strings.Contains(string(copiedReport), "# Hourly Report") {
 		t.Fatalf("output copy missing rendered report:\n%s", string(copiedReport))
 	}

@@ -423,11 +423,11 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 		t.Fatalf("decode hourly forecast: %v", err)
 	}
 	if !ok || len(hourly.Periods) != 5 {
-		t.Fatalf("hourly forecast = %#v, want five overlapping near-term periods", hourly)
+		t.Fatalf("hourly forecast = %#v, want five overlapping hourly periods", hourly)
 	}
 	hourlyJSON := mustMarshalString(t, hourly)
 	if !strings.Contains(hourlyJSON, "Showers entering the area") || !strings.Contains(hourlyJSON, "Heavy rain") {
-		t.Fatalf("hourly forecast missing selected near-term periods:\n%s", hourlyJSON)
+		t.Fatalf("hourly forecast missing selected hourly periods:\n%s", hourlyJSON)
 	}
 	if strings.Contains(hourlyJSON, "Before-window storms") || strings.Contains(hourlyJSON, "After-window rain") {
 		t.Fatalf("hourly forecast contains periods outside valid window:\n%s", hourlyJSON)
@@ -438,13 +438,13 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 		t.Fatalf("decode precip timing: %v", err)
 	}
 	if !ok || precip.MaxPopPercent == nil || *precip.MaxPopPercent != 80 || len(precip.PrecipitationWindows) != 2 {
-		t.Fatalf("precip timing = %#v, want near-term precipitation windows", precip)
+		t.Fatalf("precip timing = %#v, want hourly precipitation windows", precip)
 	}
 	if precip.PrecipitationWindows[0].PeriodBegins != "2026-05-29 at 8:00 AM" || precip.PrecipitationWindows[0].PeriodEnds != "2026-05-29 at 9:00 AM" {
 		t.Fatalf("first precip window = %#v, want first selected hour only", precip.PrecipitationWindows[0])
 	}
 	if precip.PrecipitationWindows[1].PeriodBegins != "2026-05-29 at 10:00 AM" || precip.PrecipitationWindows[1].PeriodEnds != "2026-05-29 at 12:00 PM" {
-		t.Fatalf("second precip window = %#v, want late-morning near-term rain", precip.PrecipitationWindows[1])
+		t.Fatalf("second precip window = %#v, want late-morning hourly rain", precip.PrecipitationWindows[1])
 	}

 	alerts, ok, err := module.StanzaValue[briefing.AlertDigestModule](result.ModuleSnapshot, "alert_digest")
@@ -452,7 +452,7 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 		t.Fatalf("decode alert digest: %v", err)
 	}
 	if !ok || !alerts.Checked || alerts.ActiveCount != 3 || alerts.RelevantCount != 1 || len(alerts.Relevant) != 1 || alerts.Relevant[0].Event != "Flood Watch" {
-		t.Fatalf("alert digest = %#v, want only near-term alert overlap relevant", alerts)
+		t.Fatalf("alert digest = %#v, want only hourly alert overlap relevant", alerts)
 	}

 	outlooks, ok, err := module.StanzaValue[briefing.SPCConvectiveOutlooksModule](result.ModuleSnapshot, "spc_convective_outlooks")
@@ -460,13 +460,13 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 		t.Fatalf("decode SPC outlooks: %v", err)
 	}
 	if !ok || !outlooks.Checked || outlooks.OutlookCount != 1 || len(outlooks.Outlooks) != 1 || outlooks.Outlooks[0].Label != "SLGT" {
-		t.Fatalf("SPC outlooks = %#v, want one overlapping near-term outlook", outlooks)
+		t.Fatalf("SPC outlooks = %#v, want one overlapping hourly outlook", outlooks)
 	}
 	discussion, ok, err := module.StanzaValue[briefing.SPCConvectiveDiscussionModule](result.ModuleSnapshot, "spc_convective_discussion")
 	if err != nil {
 		t.Fatalf("decode SPC discussion: %v", err)
 	}
-	if !ok || len(discussion.Discussions) != 1 || discussion.Discussions[0].Headline != "Near-term severe storms" {
+	if !ok || len(discussion.Discussions) != 1 || discussion.Discussions[0].Headline != "hourly severe storms" {
 		t.Fatalf("SPC discussion = %#v, want discussion for retained overlapping outlook", discussion)
 	}

@@ -474,11 +474,11 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 	if err != nil {
 		t.Fatalf("decode AFD: %v", err)
 	}
-	if !ok || len(afd.KeyMessages) != 1 || afd.ShortTerm != "Short-term AFD narrative for near-term report." {
+	if !ok || len(afd.KeyMessages) != 1 || afd.ShortTerm != "Short-term AFD narrative for hourly report." {
 		t.Fatalf("AFD = %#v, want key messages and short term", afd)
 	}
 	if afd.Product != "" || afd.LongTerm != "" {
-		t.Fatalf("AFD = %#v, want near-term defaults to omit product and long term", afd)
+		t.Fatalf("AFD = %#v, want hourly defaults to omit product and long term", afd)
 	}

 	if result.PriorSnapshot != nil || len(result.RecentChanges) != 0 || len(result.DataPackage.RecentChanges.Items) != 0 {
@@ -487,8 +487,8 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 	data := readDataPackageForTest(t, result)
 	text := string(data)
 	for _, want := range []string{
-		"id: near_term",
-		"prompt_id: weather.near_term_report",
+		"id: hourly",
+		"prompt_id: weather.hourly_report",
 		"valid_period:",
 		"recent_changes:",
 		"  items: []",
@@ -505,9 +505,9 @@ func TestGenerateNearTermReportWritesExpectedArtifacts(t *testing.T) {
 			t.Fatalf("data package missing %q:\n%s", want, text)
 		}
 	}
-	for _, omitted := range []string{"validPeriod:", "Before-window storms", "After-window rain", "Evening Advisory", "Day 2 outlook", "Long-term AFD narrative for near-term report."} {
+	for _, omitted := range []string{"validPeriod:", "Before-window storms", "After-window rain", "Evening Advisory", "Day 2 outlook", "Long-term AFD narrative for hourly report."} {
 		if strings.Contains(text, omitted) {
-			t.Fatalf("data package contains %q, want near-term filtered/canonical output:\n%s", omitted, text)
+			t.Fatalf("data package contains %q, want hourly filtered/canonical output:\n%s", omitted, text)
 		}
 	}
 	riskIndex := strings.Index(text, "  applicable_risk_products:")
@@ -1364,10 +1364,10 @@ func TestResolveGenerateMapsCommandToReportDefinition(t *testing.T) {
 			requestDate: time.Time{},
 		},
 		{
-			name:       "near-term",
-			kind:       ReportNearTerm,
-			wantID:     report.NearTerm,
-			wantPrompt: "weather.near_term_report",
+			name:       "hourly",
+			kind:       ReportHourly,
+			wantID:     report.Hourly,
+			wantPrompt: "weather.hourly_report",
 			wantStart:  "2026-05-29T08:00:00-05:00",
 			wantEnd:    "2026-05-29T14:00:00-05:00",
 		},
@@ -1488,7 +1488,7 @@ func dailyBundleServerWithConvectiveResponse(t *testing.T, convectiveResponse st
 	return server
 }

-func nearTermBundleServer(t *testing.T) *httptest.Server {
+func hourlyBundleServer(t *testing.T) *httptest.Server {
 	t.Helper()
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
@@ -1503,11 +1503,11 @@ func nearTermBundleServer(t *testing.T) *httptest.Server {
 		case "/alerts/active":
 			_, _ = w.Write([]byte(`{"data":{"alerts":[{"event":"Expired Advisory","headline":"Ends at valid start","severity":"Minor","effective":"2026-05-29T06:00:00-05:00","expires":"2026-05-29T08:30:00-05:00"},{"event":"Flood Watch","headline":"Flooding possible","severity":"Moderate","effective":"2026-05-29T11:00:00-05:00","expires":"2026-05-29T15:00:00-05:00"},{"event":"Evening Advisory","headline":"Starts at valid end","severity":"Minor","effective":"2026-05-29T14:30:00-05:00","expires":"2026-05-29T18:00:00-05:00"}]}}`))
 		case "/discussion":
-			_, _ = w.Write([]byte(`{"data":{"product":"discussion","issuedAt":"2026-05-29T08:05:00-05:00","keyMessages":["Storms are most likely late this morning."],"shortTerm":{"qualifier":"(Short Term)","text":"Short-term AFD narrative for near-term report."},"longTerm":{"qualifier":"(Long Term)","text":"Long-term AFD narrative for near-term report."}}}`))
+			_, _ = w.Write([]byte(`{"data":{"product":"discussion","issuedAt":"2026-05-29T08:05:00-05:00","keyMessages":["Storms are most likely late this morning."],"shortTerm":{"qualifier":"(Short Term)","text":"Short-term AFD narrative for hourly report."},"longTerm":{"qualifier":"(Long Term)","text":"Long-term AFD narrative for hourly report."}}}`))
 		case "/weatherstories/latest":
-			_, _ = w.Write([]byte(`{"data":{"officeId":"LSX","startTime":"2026-05-29T13:00:00Z","endTime":"2026-05-29T20:00:00Z","updatedAt":"2026-05-29T13:05:00Z","title":"Near-Term Storm Chances","description":"Scattered showers and thunderstorms are possible.","altText":"Weather story graphic with rain chances.","priority":true,"order":1,"downloadUrl":"https://api.weather.gov/offices/LSX/weatherstories/download/near-term"}}`))
+			_, _ = w.Write([]byte(`{"data":{"officeId":"LSX","startTime":"2026-05-29T13:00:00Z","endTime":"2026-05-29T20:00:00Z","updatedAt":"2026-05-29T13:05:00Z","title":"Hourly Storm Chances","description":"Scattered showers and thunderstorms are possible.","altText":"Weather story graphic with rain chances.","priority":true,"order":1,"downloadUrl":"https://api.weather.gov/offices/LSX/weatherstories/download/hourly"}}`))
 		case "/outlooks/convective":
-			_, _ = w.Write([]byte(`{"data":{"locationId":"home","locationName":"Brentwood","asOf":"2026-05-29T13:30:00Z","issuedAt":"2026-05-29T13:00:00Z","outlooks":[{"id":"day1-near-term","day":1,"outlookType":"categorical","label":"SLGT","labelText":"Slight Risk","severityRank":3,"validFrom":"2026-05-29T10:00:00-05:00","validTo":"2026-05-29T16:00:00-05:00","issuedAt":"2026-05-29T08:00:00-05:00","containsLocation":true},{"id":"day2-outside","day":2,"outlookType":"categorical","label":"ENH","labelText":"Day 2 outlook","severityRank":4,"validFrom":"2026-05-30T10:00:00-05:00","validTo":"2026-05-30T16:00:00-05:00","issuedAt":"2026-05-29T08:00:00-05:00","containsLocation":true}],"discussions":[{"day":1,"headline":"Near-term severe storms","summary":"Scattered severe storms are possible.","discussion":"Damaging winds may occur during the near-term window.","updatedAt":"2026-05-29T08:15:00-05:00"},{"day":2,"headline":"Day 2 discussion","summary":"Later period risk.","discussion":"This day 2 discussion should not be retained.","updatedAt":"2026-05-29T08:20:00-05:00"}]}}`))
+			_, _ = w.Write([]byte(`{"data":{"locationId":"home","locationName":"Brentwood","asOf":"2026-05-29T13:30:00Z","issuedAt":"2026-05-29T13:00:00Z","outlooks":[{"id":"day1-hourly","day":1,"outlookType":"categorical","label":"SLGT","labelText":"Slight Risk","severityRank":3,"validFrom":"2026-05-29T10:00:00-05:00","validTo":"2026-05-29T16:00:00-05:00","issuedAt":"2026-05-29T08:00:00-05:00","containsLocation":true},{"id":"day2-outside","day":2,"outlookType":"categorical","label":"ENH","labelText":"Day 2 outlook","severityRank":4,"validFrom":"2026-05-30T10:00:00-05:00","validTo":"2026-05-30T16:00:00-05:00","issuedAt":"2026-05-29T08:00:00-05:00","containsLocation":true}],"discussions":[{"day":1,"headline":"hourly severe storms","summary":"Scattered severe storms are possible.","discussion":"Damaging winds may occur during the hourly window.","updatedAt":"2026-05-29T08:15:00-05:00"},{"day":2,"headline":"Day 2 discussion","summary":"Later period risk.","discussion":"This day 2 discussion should not be retained.","updatedAt":"2026-05-29T08:20:00-05:00"}]}}`))
 		default:
 			http.NotFound(w, r)
 		}
--- a/internal/briefing/base_modules_test.go
+++ b/internal/briefing/base_modules_test.go
@@ -97,10 +97,10 @@ func TestHourlyForecastModuleRejectsUnsupportedReports(t *testing.T) {
 	}
 }

-func TestHourlyForecastModuleBuildsForNearTerm(t *testing.T) {
+func TestHourlyForecastModuleBuildsForHourly(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := testModuleContext()
-	ctx.Resolved.Definition = report.DefaultRegistry().MustLookup(report.NearTerm)
+	ctx.Resolved.Definition = report.DefaultRegistry().MustLookup(report.Hourly)

 	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.HourlyForecast})
 	if err != nil {
@@ -108,7 +108,7 @@ func TestHourlyForecastModuleBuildsForNearTerm(t *testing.T) {
 	}
 	value := moduleValue[HourlyForecastModule](t, output)
 	if len(value.Periods) != 1 || value.Periods[0].TextDescription != "Showers likely." {
-		t.Fatalf("HourlyForecast = %#v, want near-term hourly period", value)
+		t.Fatalf("HourlyForecast = %#v, want hourly report period", value)
 	}
 }

@@ -335,10 +335,10 @@ func TestAreaForecastDiscussionModuleCanSelectSections(t *testing.T) {
 	}
 }

-func TestAreaForecastDiscussionModuleUsesNearTermDefaultSections(t *testing.T) {
+func TestAreaForecastDiscussionModuleUsesHourlyDefaultSections(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := testModuleContext()
-	ctx.Resolved.Definition = report.DefaultRegistry().MustLookup(report.NearTerm)
+	ctx.Resolved.Definition = report.DefaultRegistry().MustLookup(report.Hourly)
 	var item module.ConfigItem
 	for _, candidate := range ctx.Resolved.Definition.Modules {
 		if candidate.ID == module.AreaForecastDiscussion {
@@ -347,7 +347,7 @@ func TestAreaForecastDiscussionModuleUsesNearTermDefaultSections(t *testing.T) {
 		}
 	}
 	if item.ID == "" {
-		t.Fatal("near-term default modules missing area_forecast_discussion")
+		t.Fatal("hourly default modules missing area_forecast_discussion")
 	}

 	output, err := registry.BuildModule(ctx, item)
--- a/internal/briefing/derived_modules_test.go
+++ b/internal/briefing/derived_modules_test.go
@@ -138,7 +138,7 @@ func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {

 func TestPrecipTimingModuleUsesDerivedTimingWithoutDaypartSummaries(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	ctx := derivedModuleContext(report.NearTerm)
+	ctx := derivedModuleContext(report.Hourly)
 	ctx.Derived.DailySummaries = nil
 	ctx.Derived.DaypartSummaries = nil

--- a/internal/briefing/modules.go
+++ b/internal/briefing/modules.go
@@ -249,7 +249,7 @@ func (d ModuleDefinition) ValidateOptions(options any) error {
 }

 func defaultModuleDefinitions() []ModuleDefinition {
-	allReports := []report.ID{report.DailyToday, report.DailyTomorrow, report.NearTerm, report.ThreeDay, report.Weekend, report.Storm}
+	allReports := []report.ID{report.DailyToday, report.DailyTomorrow, report.Hourly, report.ThreeDay, report.Weekend, report.Storm}
 	daypartReports := []report.ID{report.DailyToday, report.DailyTomorrow, report.ThreeDay, report.Weekend}
 	return []ModuleDefinition{
 		{
@@ -286,7 +286,7 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			DefaultOptions:    module.HourlyForecastOptions{},
 			RequiredCollected: []module.FactRequirement{module.CollectedHourlyForecast},
 			RequiredDerived:   []module.FactRequirement{module.RequiresDerivedHourlyPeriods},
-			SupportedReports:  []report.ID{report.DailyToday, report.DailyTomorrow, report.NearTerm},
+			SupportedReports:  []report.ID{report.DailyToday, report.DailyTomorrow, report.Hourly},
 			MissingData:       module.MissingDataOmit,
 			Builder:           buildHourlyForecastModule,
 		},
--- a/internal/briefing/modules_test.go
+++ b/internal/briefing/modules_test.go
@@ -54,8 +54,8 @@ func TestDefaultReportModulesBuildSnapshots(t *testing.T) {
 	}
 }

-func TestNearTermDefaultModuleOptions(t *testing.T) {
-	definition := report.DefaultRegistry().MustLookup(report.NearTerm)
+func TestHourlyDefaultModuleOptions(t *testing.T) {
+	definition := report.DefaultRegistry().MustLookup(report.Hourly)
 	var found bool
 	for _, item := range definition.Modules {
 		if item.ID != module.AreaForecastDiscussion {
@@ -71,7 +71,7 @@ func TestNearTermDefaultModuleOptions(t *testing.T) {
 		}
 	}
 	if !found {
-		t.Fatal("near-term default modules missing area_forecast_discussion")
+		t.Fatal("hourly default modules missing area_forecast_discussion")
 	}
 }

@@ -112,7 +112,7 @@ func TestModuleRegistryRejectsIncompatibleReports(t *testing.T) {
 	}
 }

-func TestModuleRegistryRejectsNearTermIncompatibleModules(t *testing.T) {
+func TestModuleRegistryRejectsHourlyIncompatibleModules(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	for _, id := range []module.ID{
 		module.NarrativeForecast,
@@ -122,9 +122,9 @@ func TestModuleRegistryRejectsNearTermIncompatibleModules(t *testing.T) {
 		module.TomorrowPlanning,
 	} {
 		t.Run(string(id), func(t *testing.T) {
-			err := registry.ValidateComposition(report.NearTerm, []module.ConfigItem{{ID: id}})
-			if err == nil || !strings.Contains(err.Error(), `not compatible with report "near_term"`) {
-				t.Fatalf("ValidateComposition() error = %v, want incompatible near-term module", err)
+			err := registry.ValidateComposition(report.Hourly, []module.ConfigItem{{ID: id}})
+			if err == nil || !strings.Contains(err.Error(), `not compatible with report "hourly"`) {
+				t.Fatalf("ValidateComposition() error = %v, want incompatible hourly module", err)
 			}
 		})
 	}
--- a/internal/cli/root.go
+++ b/internal/cli/root.go
@@ -19,7 +19,7 @@ Usage:
  weatherreporter --help
  weatherreporter generate daily [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--date YYYY-MM-DD]
  weatherreporter generate tomorrow [--config PATH] [--units VALUE] [--tz NAME] [--out PATH]
-  weatherreporter generate near-term [--config PATH] [--units VALUE] [--tz NAME] [--out PATH]
+  weatherreporter generate hourly [--config PATH] [--units VALUE] [--tz NAME] [--out PATH]
  weatherreporter generate three-day [--config PATH] [--units VALUE] [--tz NAME] [--out PATH]
  weatherreporter generate weekend [--config PATH] [--units VALUE] [--tz NAME] [--out PATH]
  weatherreporter generate storm [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] --start TIME --end TIME
@@ -387,8 +387,8 @@ func reportKind(value string) (app.ReportKind, bool) {
 		return app.ReportDaily, true
 	case string(app.ReportTomorrow):
 		return app.ReportTomorrow, true
-	case string(app.ReportNearTerm):
-		return app.ReportNearTerm, true
+	case string(app.ReportHourly):
+		return app.ReportHourly, true
 	case string(app.ReportThreeDay):
 		return app.ReportThreeDay, true
 	case string(app.ReportWeekend):
--- a/internal/cli/root_test.go
+++ b/internal/cli/root_test.go
@@ -28,8 +28,8 @@ func TestRunHelpLongFlag(t *testing.T) {
 	if !strings.Contains(stdout.String(), "generate daily") {
 		t.Fatalf("help output missing generate command:\n%s", stdout.String())
 	}
-	if !strings.Contains(stdout.String(), "weatherreporter generate near-term") {
-		t.Fatalf("help output missing near-term generate command:\n%s", stdout.String())
+	if !strings.Contains(stdout.String(), "weatherreporter generate hourly") {
+		t.Fatalf("help output missing hourly generate command:\n%s", stdout.String())
 	}
 	removedInspectCommand := "inspect " + "briefing"
 	if !strings.Contains(stdout.String(), "inspect modules") || strings.Contains(stdout.String(), removedInspectCommand) {
@@ -812,7 +812,7 @@ func TestResolveGenerateCommands(t *testing.T) {
 	}{
 		{name: "daily", args: []string{"daily", "--date", "2026-05-29"}, want: app.ReportDaily},
 		{name: "tomorrow", args: []string{"tomorrow"}, want: app.ReportTomorrow},
-		{name: "near-term", args: []string{"near-term"}, want: app.ReportNearTerm},
+		{name: "hourly", args: []string{"hourly"}, want: app.ReportHourly},
 		{name: "three-day", args: []string{"three-day"}, want: app.ReportThreeDay},
 		{name: "weekend", args: []string{"weekend"}, want: app.ReportWeekend},
 		{name: "storm", args: []string{"storm", "--start", "2026-05-29T18:00", "--end", "2026-05-30T06:00"}, want: app.ReportStorm},
@@ -831,20 +831,20 @@ func TestResolveGenerateCommands(t *testing.T) {
 	}
 }

-func TestResolveGenerateNearTermAppliesSharedFlags(t *testing.T) {
+func TestResolveGenerateHourlyAppliesSharedFlags(t *testing.T) {
 	runner := Runner{Clock: fixedClock()}
 	configPath := filepath.Join(t.TempDir(), "config.yml")
 	if err := os.WriteFile(configPath, []byte("weather_api:\n  units: metric\n  timezone: UTC\n"), 0o600); err != nil {
 		t.Fatalf("write config: %v", err)
 	}

-	req, err := runner.resolveGenerate([]string{"near-term", "--config", configPath, "--units", "us", "--tz", "America/Chicago", "--out", "./near-term.md"})
+	req, err := runner.resolveGenerate([]string{"hourly", "--config", configPath, "--units", "us", "--tz", "America/Chicago", "--out", "./hourly.md"})
 	if err != nil {
 		t.Fatalf("resolveGenerate() error = %v", err)
 	}

-	if req.Report != app.ReportNearTerm {
-		t.Fatalf("Report = %q, want near-term", req.Report)
+	if req.Report != app.ReportHourly {
+		t.Fatalf("Report = %q, want hourly", req.Report)
 	}
 	if req.Config.WeatherAPI.Units != "us" {
 		t.Fatalf("Units = %q, want us", req.Config.WeatherAPI.Units)
@@ -852,21 +852,21 @@ func TestResolveGenerateNearTermAppliesSharedFlags(t *testing.T) {
 	if req.Config.WeatherAPI.Timezone != "America/Chicago" {
 		t.Fatalf("Timezone = %q, want America/Chicago", req.Config.WeatherAPI.Timezone)
 	}
-	if req.OutputPath != "./near-term.md" {
-		t.Fatalf("OutputPath = %q, want ./near-term.md", req.OutputPath)
+	if req.OutputPath != "./hourly.md" {
+		t.Fatalf("OutputPath = %q, want ./hourly.md", req.OutputPath)
 	}
 	if !req.Date.IsZero() || !req.StormStart.IsZero() || !req.StormEnd.IsZero() {
-		t.Fatalf("date/storm bounds = %s/%s/%s, want unset for near-term", req.Date, req.StormStart, req.StormEnd)
+		t.Fatalf("date/storm bounds = %s/%s/%s, want unset for hourly", req.Date, req.StormStart, req.StormEnd)
 	}
 }

-func TestResolveGenerateNearTermRejectsDateAndStormBounds(t *testing.T) {
+func TestResolveGenerateHourlyRejectsDateAndStormBounds(t *testing.T) {
 	runner := Runner{Clock: fixedClock()}

 	for _, args := range [][]string{
-		{"near-term", "--date", "2026-05-29"},
-		{"near-term", "--start", "2026-05-29T18:00"},
-		{"near-term", "--end", "2026-05-29T20:00"},
+		{"hourly", "--date", "2026-05-29"},
+		{"hourly", "--start", "2026-05-29T18:00"},
+		{"hourly", "--end", "2026-05-29T20:00"},
 	} {
 		_, err := runner.resolveGenerate(args)
 		if err == nil {
--- a/internal/config/config_test.go
+++ b/internal/config/config_test.go
@@ -161,19 +161,10 @@ reports:
 	}
 }

-func TestLoadNearTermReportModuleOverrides(t *testing.T) {
-	tests := []struct {
-		name string
-		key  string
-	}{
-		{name: "UnderscoreAlias", key: "near_term"},
-		{name: "HyphenAlias", key: "near-term"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			path := writeConfig(t, `
+func TestLoadHourlyReportModuleOverrides(t *testing.T) {
+	path := writeConfig(t, `
 reports:
-  `+tt.key+`:
+  hourly:
    deterministic_modules:
      - metadata
      - hourly_forecast
@@ -181,22 +172,20 @@ reports:
      - alert_digest
 `)

-			cfg, err := LoadFile(path)
-			if err != nil {
-				t.Fatalf("LoadFile() error = %v", err)
-			}
-			overrides := cfg.ReportModuleOverrides()
-			items := overrides[report.NearTerm]
-			if len(items) != 4 {
-				t.Fatalf("near-term override length = %d, want 4", len(items))
-			}
-			if items[0].ID != module.Metadata ||
-				items[1].ID != module.HourlyForecast ||
-				items[2].ID != module.PrecipTiming ||
-				items[3].ID != module.AlertDigest {
-				t.Fatalf("near-term override = %#v, want configured module order", items)
-			}
-		})
+	cfg, err := LoadFile(path)
+	if err != nil {
+		t.Fatalf("LoadFile() error = %v", err)
+	}
+	overrides := cfg.ReportModuleOverrides()
+	items := overrides[report.Hourly]
+	if len(items) != 4 {
+		t.Fatalf("hourly override length = %d, want 4", len(items))
+	}
+	if items[0].ID != module.Metadata ||
+		items[1].ID != module.HourlyForecast ||
+		items[2].ID != module.PrecipTiming ||
+		items[3].ID != module.AlertDigest {
+		t.Fatalf("hourly override = %#v, want configured module order", items)
 	}
 }

@@ -284,27 +273,14 @@ reports:
 			wantErr: "duplicates report override",
 		},
 		{
-			name: "DuplicateNearTermAlias",
+			name: "HourlyIncompatibleDailyModule",
 			yaml: `
 reports:
-  near_term:
-    deterministic_modules:
-      - metadata
-  near-term:
-    deterministic_modules:
-      - current_conditions
-`,
-			wantErr: "duplicates report override",
-		},
-		{
-			name: "NearTermIncompatibleDailyModule",
-			yaml: `
-reports:
-  near_term:
+  hourly:
    deterministic_modules:
      - derived_daily_summary
 `,
-			wantErr: `not compatible with report "near_term"`,
+			wantErr: `not compatible with report "hourly"`,
 		},
 		{
 			name: "UnknownReportField",
--- a/internal/config/reports.go
+++ b/internal/config/reports.go
@@ -113,8 +113,8 @@ func reportIDForConfigKey(key string) (report.ID, error) {
 		return report.DailyToday, nil
 	case "tomorrow", "daily_tomorrow":
 		return report.DailyTomorrow, nil
-	case "near_term":
-		return report.NearTerm, nil
+	case "hourly":
+		return report.Hourly, nil
 	case "three_day", "three_day_outlook":
 		return report.ThreeDay, nil
 	case "weekend", "weekend_outlook":
--- a/internal/facts/facts.go
+++ b/internal/facts/facts.go
@@ -114,7 +114,7 @@ func BuildDerived(req BuildDerivedRequest) (DerivedFacts, error) {
 	derived.PrecipTiming = forecast.BuildPrecipTiming(derived.ValidPeriodHourlyPeriods)

 	switch req.Resolved.Definition.ID {
-	case report.NearTerm:
+	case report.Hourly:
 	case report.DailyToday, report.DailyTomorrow:
 		summary, err := forecast.BuildDailySummary(bundle, period.Start, location, req.Dayparts)
 		if err != nil {
--- a/internal/facts/facts_test.go
+++ b/internal/facts/facts_test.go
@@ -152,9 +152,9 @@ func TestBuildDerivedWeekendAndTomorrow(t *testing.T) {
 	}
 }

-func TestBuildDerivedNearTermUsesRollingWindowFacts(t *testing.T) {
+func TestBuildDerivedHourlyUsesRollingWindowFacts(t *testing.T) {
 	location := testLocation()
-	resolved := resolveForTest(t, report.NearTerm, mustParse("2026-05-29T08:30:00-05:00"), location)
+	resolved := resolveForTest(t, report.Hourly, mustParse("2026-05-29T08:30:00-05:00"), location)
 	bundle := testBundle(location)
 	bundle.Alerts = &weatherdata.AlertRun{Alerts: []json.RawMessage{
 		json.RawMessage(`{"event":"Expired Advisory","headline":"Ends at start","severity":"Minor","effective":"2026-05-29T05:00:00-05:00","expires":"2026-05-29T08:30:00-05:00"}`),
@@ -184,7 +184,7 @@ func TestBuildDerivedNearTermUsesRollingWindowFacts(t *testing.T) {
 		t.Fatalf("ValidPeriodNarrativePeriods length = %d, want overlapping narrative period", len(derived.ValidPeriodNarrativePeriods))
 	}
 	if len(derived.DailySummaries) != 0 || len(derived.DaypartSummaries) != 0 || derived.StormWindowSummary != nil {
-		t.Fatalf("near-term summaries daily=%#v daypart=%#v storm=%#v, want none", derived.DailySummaries, derived.DaypartSummaries, derived.StormWindowSummary)
+		t.Fatalf("hourly summaries daily=%#v daypart=%#v storm=%#v, want none", derived.DailySummaries, derived.DaypartSummaries, derived.StormWindowSummary)
 	}
 	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 first selected rainy hour", derived.PrecipTiming.FirstPrecipitation)
@@ -193,13 +193,13 @@ func TestBuildDerivedNearTermUsesRollingWindowFacts(t *testing.T) {
 		t.Fatalf("PrecipTiming.LastPrecipitation = %#v, want final selected rainy window end", derived.PrecipTiming.LastPrecipitation)
 	}
 	if len(derived.PrecipTiming.PrecipitationWindows) != 2 {
-		t.Fatalf("PrecipTiming.PrecipitationWindows = %#v, want two near-term windows", derived.PrecipTiming.PrecipitationWindows)
+		t.Fatalf("PrecipTiming.PrecipitationWindows = %#v, want two hourly windows", derived.PrecipTiming.PrecipitationWindows)
 	}
 	if len(derived.AlertOverlaps) != 1 || derived.AlertOverlaps[0].Event != "Flood Watch" {
-		t.Fatalf("AlertOverlaps = %#v, want only alert overlapping near-term period", derived.AlertOverlaps)
+		t.Fatalf("AlertOverlaps = %#v, want only alert overlapping hourly period", derived.AlertOverlaps)
 	}
 	if derived.AlertOverlaps[0].Overlap.End.Format(time.RFC3339) != "2026-05-29T14:30:00-05:00" {
-		t.Fatalf("Alert overlap end = %s, want clipped to near-term end", derived.AlertOverlaps[0].Overlap.End.Format(time.RFC3339))
+		t.Fatalf("Alert overlap end = %s, want clipped to hourly end", derived.AlertOverlaps[0].Overlap.End.Format(time.RFC3339))
 	}
 	if got, want := outlookIDs(derived.SPCConvectiveOutlooks), []string{"fri-high", "fri-storm", "fri-low", "fri-missing-rank", "fri-probabilistic"}; strings.Join(got, ",") != strings.Join(want, ",") {
 		t.Fatalf("SPCConvectiveOutlooks IDs = %#v, want %#v", got, want)
@@ -306,7 +306,7 @@ func TestBuildDerivedSelectsSPCConvectiveOutlooksByValidPeriod(t *testing.T) {

 func TestBuildDerivedUnsupportedReportReturnsActionableError(t *testing.T) {
 	location := testLocation()
-	resolved := resolveForTest(t, report.NearTerm, mustParse("2026-05-29T08:00:00-05:00"), location)
+	resolved := resolveForTest(t, report.Hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
 	resolved.Definition.ID = report.ID("future_report")

 	_, err := BuildDerived(BuildDerivedRequest{
--- a/internal/report/definition.go
+++ b/internal/report/definition.go
@@ -14,7 +14,7 @@ type ID string
 const (
 	DailyToday    ID = "daily_today"
 	DailyTomorrow ID = "daily_tomorrow"
-	NearTerm      ID = "near_term"
+	Hourly        ID = "hourly"
 	ThreeDay      ID = "three_day"
 	Weekend       ID = "weekend"
 	Storm         ID = "storm"
--- a/internal/report/near_term_report.go
+++ b/internal/report/near_term_report.go
@@ -7,24 +7,24 @@ import (
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 )

-const nearTermHours = 6
+const hourlyHours = 6

-func nearTermDefinition() Definition {
+func hourlyDefinition() Definition {
 	return Definition{
-		ID:                 NearTerm,
-		Name:               "Near-Term Report",
-		PromptID:           "weather.near_term_report",
+		ID:                 Hourly,
+		Name:               "Hourly Report",
+		PromptID:           "weather.hourly_report",
 		ComparisonStrategy: CompareRollingWindow,
-		ArtifactGroup:      "near-term",
-		BatchOutputName:    "near-term.md",
+		ArtifactGroup:      "hourly",
+		BatchOutputName:    "hourly.md",
 		Generated:          true,
-		CompatiblePriorIDs: []ID{NearTerm},
-		Modules:            nearTermModules(),
-		resolve:            resolveNearTerm,
+		CompatiblePriorIDs: []ID{Hourly},
+		Modules:            hourlyModules(),
+		resolve:            resolveHourly,
 	}
 }

-func nearTermModules() []module.ConfigItem {
+func hourlyModules() []module.ConfigItem {
 	return []module.ConfigItem{
 		{ID: module.Metadata},
 		{ID: module.CurrentConditions},
@@ -43,10 +43,10 @@ func nearTermModules() []module.ConfigItem {
 	}
 }

-func resolveNearTerm(req ResolveRequest) (timeutil.Period, error) {
+func resolveHourly(req ResolveRequest) (timeutil.Period, error) {
 	localNow := req.Now.In(req.Location)
 	return timeutil.Period{
 		Start: localNow,
-		End:   localNow.Add(nearTermHours * time.Hour),
+		End:   localNow.Add(hourlyHours * time.Hour),
 	}, nil
 }
--- a/internal/report/period_test.go
+++ b/internal/report/period_test.go
@@ -58,19 +58,19 @@ func TestThreeDayPeriodCalculation(t *testing.T) {
 	assertPeriod(t, resolved.ValidPeriod, "2026-05-29T05:00:00-05:00", "2026-06-01T00:00:00-05:00")
 }

-func TestNearTermLookupAndPeriodCalculation(t *testing.T) {
+func TestHourlyLookupAndPeriodCalculation(t *testing.T) {
 	location := mustLoadLocation(t)
 	now := mustParse("2026-05-29T05:15:00-05:00")

-	resolved, err := Resolve(NearTerm, ResolveRequest{Now: now, Location: location})
+	resolved, err := Resolve(Hourly, ResolveRequest{Now: now, Location: location})
 	if err != nil {
 		t.Fatalf("Resolve() error = %v", err)
 	}
-	if resolved.Definition.ID != NearTerm {
-		t.Fatalf("ID = %q, want near_term", resolved.Definition.ID)
+	if resolved.Definition.ID != Hourly {
+		t.Fatalf("ID = %q, want hourly", resolved.Definition.ID)
 	}
-	if resolved.Definition.PromptID != "weather.near_term_report" {
-		t.Fatalf("PromptID = %q, want weather.near_term_report", resolved.Definition.PromptID)
+	if resolved.Definition.PromptID != "weather.hourly_report" {
+		t.Fatalf("PromptID = %q, want weather.hourly_report", resolved.Definition.PromptID)
 	}
 	if resolved.Definition.ComparisonStrategy != CompareRollingWindow {
 		t.Fatalf("ComparisonStrategy = %q, want rolling_window", resolved.Definition.ComparisonStrategy)
@@ -78,25 +78,25 @@ func TestNearTermLookupAndPeriodCalculation(t *testing.T) {
 	assertPeriod(t, resolved.ValidPeriod, "2026-05-29T05:15:00-05:00", "2026-05-29T11:15:00-05:00")
 }

-func TestNearTermPeriodUsesEffectiveTimezone(t *testing.T) {
+func TestHourlyPeriodUsesEffectiveTimezone(t *testing.T) {
 	location, err := time.LoadLocation("America/New_York")
 	if err != nil {
 		t.Fatalf("load location: %v", err)
 	}
 	now := mustParse("2026-05-29T10:15:00Z")

-	resolved, err := Resolve(NearTerm, ResolveRequest{Now: now, Location: location})
+	resolved, err := Resolve(Hourly, ResolveRequest{Now: now, Location: location})
 	if err != nil {
 		t.Fatalf("Resolve() error = %v", err)
 	}
 	assertPeriod(t, resolved.ValidPeriod, "2026-05-29T06:15:00-04:00", "2026-05-29T12:15:00-04:00")
 }

-func TestNearTermPeriodIsNotCivilDayTruncated(t *testing.T) {
+func TestHourlyPeriodIsNotCivilDayTruncated(t *testing.T) {
 	location := mustLoadLocation(t)
 	now := mustParse("2026-05-29T22:30:00-05:00")

-	resolved, err := Resolve(NearTerm, ResolveRequest{Now: now, Location: location})
+	resolved, err := Resolve(Hourly, ResolveRequest{Now: now, Location: location})
 	if err != nil {
 		t.Fatalf("Resolve() error = %v", err)
 	}
@@ -203,7 +203,7 @@ func TestEveningBatchIncludesTomorrow(t *testing.T) {
 	}
 }

-func TestBatchesDoNotIncludeNearTerm(t *testing.T) {
+func TestBatchesDoNotIncludeHourly(t *testing.T) {
 	location := mustLoadLocation(t)
 	req := ResolveRequest{Now: mustParse("2026-05-29T06:00:00-05:00"), Location: location}

@@ -216,8 +216,8 @@ func TestBatchesDoNotIncludeNearTerm(t *testing.T) {
 		t.Fatalf("BatchReports(evening) error = %v", err)
 	}
 	for _, resolved := range append(morning, evening...) {
-		if resolved.Definition.ID == NearTerm {
-			t.Fatalf("batch included %q, want near-term excluded", resolved.Definition.ID)
+		if resolved.Definition.ID == Hourly {
+			t.Fatalf("batch included %q, want hourly excluded", resolved.Definition.ID)
 		}
 	}
 }
@@ -232,9 +232,9 @@ func TestRegistryLookupErrorIsActionable(t *testing.T) {
 	}
 }

-func TestRegistryAllIncludesNearTermInStableOrder(t *testing.T) {
+func TestRegistryAllIncludesHourlyInStableOrder(t *testing.T) {
 	ids := resolvedDefinitionIDs(DefaultRegistry().All())
-	want := []string{"daily_today", "daily_tomorrow", "near_term", "three_day", "weekend", "storm"}
+	want := []string{"daily_today", "daily_tomorrow", "hourly", "three_day", "weekend", "storm"}
 	if strings.Join(ids, ",") != strings.Join(want, ",") {
 		t.Fatalf("All() ids = %#v, want %#v", ids, want)
 	}
@@ -277,11 +277,11 @@ func TestRegistryDefinitionsDeclarePathAndCompatibilityPolicy(t *testing.T) {
 			comparisonStrategy: CompareSameValidDate,
 		},
 		{
-			id:                 NearTerm,
-			artifactGroup:      "near-term",
-			batchOutputName:    "near-term.md",
+			id:                 Hourly,
+			artifactGroup:      "hourly",
+			batchOutputName:    "hourly.md",
 			generated:          true,
-			compatiblePriorIDs: []ID{NearTerm},
+			compatiblePriorIDs: []ID{Hourly},
 			comparisonStrategy: CompareRollingWindow,
 		},
 		{
@@ -384,7 +384,7 @@ func TestRegistryDefinitionsDeclareDefaultModules(t *testing.T) {
 			},
 		},
 		{
-			id: NearTerm,
+			id: Hourly,
 			want: []module.ID{
 				module.Metadata,
 				module.CurrentConditions,
@@ -515,20 +515,20 @@ func TestResolvedMetadata(t *testing.T) {
 	}
 }

-func TestNearTermMetadataRunIDIncludesReportID(t *testing.T) {
+func TestHourlyMetadataRunIDIncludesReportID(t *testing.T) {
 	location := mustLoadLocation(t)
-	resolved, err := Resolve(NearTerm, ResolveRequest{Now: mustParse("2026-05-29T05:15:00-05:00"), Location: location})
+	resolved, err := Resolve(Hourly, ResolveRequest{Now: mustParse("2026-05-29T05:15:00-05:00"), Location: location})
 	if err != nil {
 		t.Fatalf("Resolve() error = %v", err)
 	}
 	metadata := resolved.Metadata()
-	if metadata.ReportID != NearTerm {
-		t.Fatalf("ReportID = %q, want near_term", metadata.ReportID)
+	if metadata.ReportID != Hourly {
+		t.Fatalf("ReportID = %q, want hourly", metadata.ReportID)
 	}
-	if metadata.PromptID != "weather.near_term_report" {
-		t.Fatalf("PromptID = %q, want weather.near_term_report", metadata.PromptID)
+	if metadata.PromptID != "weather.hourly_report" {
+		t.Fatalf("PromptID = %q, want weather.hourly_report", metadata.PromptID)
 	}
-	if !strings.Contains(metadata.RunID, "near_term") {
+	if !strings.Contains(metadata.RunID, "hourly") {
 		t.Fatalf("RunID = %q, want report id", metadata.RunID)
 	}
 }
--- a/internal/report/registry.go
+++ b/internal/report/registry.go
@@ -14,7 +14,7 @@ func DefaultRegistry() Registry {
 	definitions := []Definition{
 		dailyTodayDefinition(),
 		dailyTomorrowDefinition(),
-		nearTermDefinition(),
+		hourlyDefinition(),
 		threeDayDefinition(),
 		weekendDefinition(),
 		stormDefinition(),
@@ -74,7 +74,7 @@ func (r Registry) MustLookup(id ID) Definition {
 }

 func (r Registry) All() []Definition {
-	ids := []ID{DailyToday, DailyTomorrow, NearTerm, ThreeDay, Weekend, Storm}
+	ids := []ID{DailyToday, DailyTomorrow, Hourly, ThreeDay, Weekend, Storm}
 	out := make([]Definition, 0, len(ids))
 	for _, id := range ids {
 		if definition, ok := r.definitions[id]; ok {
--- a/internal/state/filesystem_test.go
+++ b/internal/state/filesystem_test.go
@@ -307,8 +307,8 @@ func TestFindPriorSnapshotSupportsNarrowedWeekendPeriod(t *testing.T) {

 func TestFindPriorSnapshotIgnoresRollingWindowReports(t *testing.T) {
 	store := newTestStore(t)
-	first := resolveNearTermAt(t, "2026-05-29T05:00:00-05:00")
-	second := resolveNearTermAt(t, "2026-05-29T06:00:00-05:00")
+	first := resolveHourlyAt(t, "2026-05-29T05:00:00-05:00")
+	second := resolveHourlyAt(t, "2026-05-29T06:00:00-05:00")
 	savePriorMetadata(t, store, first, stateBriefingMetadata(first))

 	prior, err := store.FindPriorSnapshot(context.Background(), second)
@@ -405,7 +405,7 @@ func resolveWeekendAt(t *testing.T, value string) report.Resolved {
 	return resolved
 }

-func resolveNearTermAt(t *testing.T, value string) report.Resolved {
+func resolveHourlyAt(t *testing.T, value string) report.Resolved {
 	t.Helper()
 	location, err := timeutil.LoadLocation("America/Chicago")
 	if err != nil {
@@ -415,7 +415,7 @@ func resolveNearTermAt(t *testing.T, value string) report.Resolved {
 	if err != nil {
 		t.Fatalf("parse time: %v", err)
 	}
-	resolved, err := report.DefaultRegistry().Resolve(report.NearTerm, report.ResolveRequest{
+	resolved, err := report.DefaultRegistry().Resolve(report.Hourly, report.ResolveRequest{
 		Now:      now,
 		Location: location,
 	})