Remove obsolete briefing snapshot artifacts

internal/app/app.go

@@ -68,12 +68,6 @@ type FetchBundleRequest struct {
 	OutputPath string
 }
 
-type BriefingRequest struct {
-	Config     config.Config
-	Resolved   report.Resolved
-	OutputPath string
-}
-
 type ModuleSnapshotRequest struct {
 	Config   config.Config
 	Resolved report.Resolved
@@ -93,15 +87,8 @@ type ReportRequest struct {
 	Notifier   Notifier
 }
 
-type BriefingResult struct {
-	Package    briefing.Package
-	OutputPath string
-}
-
 type ReportResult struct {
-	Briefing           briefing.Package
 	ModuleSnapshot     module.Snapshot
-	BriefingPath       string
 	ModuleSnapshotPath string
 	DataPackage        promptinput.Package
 	DataPackagePath    string
@@ -142,7 +129,6 @@ type BatchReportResult struct {
 	NotificationPath       string          `json:"notificationPath,omitempty"`
 	GeneratedAt            time.Time       `json:"generatedAt"`
 	ValidPeriod            timeutil.Period `json:"validPeriod"`
-	BriefingPath           string          `json:"briefingPath,omitempty"`
 	DataPackagePath        string          `json:"dataPackagePath,omitempty"`
 	PreflightPath          string          `json:"preflightPath,omitempty"`
 	ReportPath             string          `json:"reportPath,omitempty"`
@@ -275,7 +261,6 @@ func RunBatchDetailed(ctx context.Context, req BatchRequest) (*BatchResult, erro
 		for _, resolved := range resolvedReports {
 			item := batchReportResult(resolved)
 			if paths, err := store.Paths(resolved); err == nil {
-				item.BriefingPath = paths.Briefing
 				item.DataPackagePath = paths.DataPackage
 				item.PreflightPath = paths.Preflight
 				item.ReportPath = paths.RenderedReport
@@ -305,7 +290,6 @@ func RunBatchDetailed(ctx context.Context, req BatchRequest) (*BatchResult, erro
 				result.Failed++
 			} else {
 				item.Status = "succeeded"
-				item.BriefingPath = reportResult.BriefingPath
 				item.DataPackagePath = reportResult.DataPackagePath
 				item.PreflightPath = reportResult.PreflightPath
 				item.ReportPath = reportResult.ReportPath
@@ -450,33 +434,6 @@ func FetchAndSaveBundle(ctx context.Context, req FetchBundleRequest) (*weatherda
 	return bundle, nil
 }
 
-func GenerateBriefing(ctx context.Context, req BriefingRequest) (*BriefingResult, error) {
-	bundle, err := FetchBundle(ctx, FetchBundleRequest{Config: req.Config})
-	if err != nil {
-		return nil, err
-	}
-	pkg, err := BuildBriefing(req, bundle)
-	if err != nil {
-		return nil, err
-	}
-	outputPath := req.OutputPath
-	if outputPath == "" {
-		store, err := defaultStore(req.Config)
-		if err != nil {
-			return nil, err
-		}
-		paths, err := store.Paths(req.Resolved)
-		if err != nil {
-			return nil, err
-		}
-		outputPath = paths.Briefing
-	}
-	if err := briefing.Save(outputPath, pkg); err != nil {
-		return nil, err
-	}
-	return &BriefingResult{Package: pkg, OutputPath: outputPath}, nil
-}
-
 func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, error) {
 	store := req.Store
 	if store == nil {
@@ -518,17 +475,6 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 	if err != nil {
 		return nil, err
 	}
-	briefingPackage, err := BuildBriefingFromFacts(BriefingRequest{
-		Config:   req.Config,
-		Resolved: req.Resolved,
-	}, reportFacts)
-	if err != nil {
-		return nil, err
-	}
-	briefingPath, err := store.SaveBriefing(ctx, req.Resolved, briefingPackage)
-	if err != nil {
-		return nil, err
-	}
 
 	recentChanges, err := recentChanges(ctx, store, priorSnapshot, req.Resolved.Definition.ID, moduleSnapshot, req.Config.RecentChange)
 	if err != nil {
@@ -536,7 +482,6 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 	}
 	briefingMetadata := briefing.BuildMetadata(briefingBuildContext(req.Config, req.Resolved, reportFacts.Collected))
 	metadata := state.BuildMetadataFromBriefingMetadata(req.Resolved, briefingMetadata, state.ArtifactPaths{
-		Briefing:       briefingPath,
 		ModuleSnapshot: moduleSnapshotPath,
 		Metadata:       paths.Metadata,
 		DataPackage:    paths.DataPackage,
@@ -629,9 +574,7 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 	}
 
 	return &ReportResult{
-		Briefing:           briefingPackage,
 		ModuleSnapshot:     moduleSnapshot,
-		BriefingPath:       briefingPath,
 		ModuleSnapshotPath: moduleSnapshotPath,
 		DataPackage:        dataPackage,
 		DataPackagePath:    dataPackagePath,
@@ -846,34 +789,6 @@ func distributorUploadFiles(sourcePath string, bundlePaths []string) []distribut
 	return files
 }
 
-func BuildBriefing(req BriefingRequest, bundle *weatherdata.Bundle) (briefing.Package, error) {
-	reportFacts, err := BuildReportFacts(ModuleSnapshotRequest{
-		Config:   req.Config,
-		Resolved: req.Resolved,
-	}, bundle)
-	if err != nil {
-		return briefing.Package{}, err
-	}
-	return BuildBriefingFromFacts(req, reportFacts)
-}
-
-func BuildBriefingFromFacts(req BriefingRequest, reportFacts ReportFacts) (briefing.Package, error) {
-	buildContext := briefingBuildContext(req.Config, req.Resolved, reportFacts.Collected)
-	switch req.Resolved.Definition.ID {
-	case report.DailyToday, report.DailyTomorrow:
-		return briefing.BuildDaily(buildContext, reportFacts.Derived.FirstDailySummary())
-	case report.ThreeDay, report.Weekend:
-		if req.Resolved.Definition.ID == report.Weekend {
-			return briefing.BuildWeekend(buildContext, reportFacts.Derived.DailySummaries)
-		}
-		return briefing.BuildThreeDay(buildContext, reportFacts.Derived.DailySummaries)
-	case report.Storm:
-		return briefing.BuildStorm(buildContext, reportFacts.Derived)
-	default:
-		return briefing.Package{}, fmt.Errorf("briefing is not implemented for report %q", req.Resolved.Definition.ID)
-	}
-}
-
 func BuildModuleSnapshot(req ModuleSnapshotRequest, bundle *weatherdata.Bundle) (module.Snapshot, error) {
 	reportFacts, err := BuildReportFacts(req, bundle)
 	if err != nil {

internal/app/app_test.go

@@ -15,7 +15,6 @@ import (
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/scriptorium"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
@@ -79,67 +78,6 @@ func TestFetchAndSaveBundleRequiresOutputPath(t *testing.T) {
 	}
 }
 
-func TestGenerateBriefingWritesArtifact(t *testing.T) {
-	server := dailyBundleServer(t)
-	cfg := dailyTestConfig(t, server)
-	resolved, err := ResolveGenerate(GenerateRequest{
-		Config: cfg,
-		Report: ReportDaily,
-		Date:   mustParse("2026-05-29T12:00:00-05:00"),
-	}, mustParse("2026-05-29T05:00:00-05:00"))
-	if err != nil {
-		t.Fatalf("ResolveGenerate() error = %v", err)
-	}
-	path := filepath.Join(t.TempDir(), "daily.briefing.json")
-
-	result, err := GenerateBriefing(context.Background(), BriefingRequest{
-		Config:     cfg,
-		Resolved:   resolved,
-		OutputPath: path,
-	})
-	if err != nil {
-		t.Fatalf("GenerateBriefing() error = %v", err)
-	}
-	if result.OutputPath != path {
-		t.Fatalf("OutputPath = %q, want %q", result.OutputPath, path)
-	}
-	if result.Package.Daily == nil {
-		t.Fatal("Daily = nil")
-	}
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("read briefing artifact: %v", err)
-	}
-	if !strings.Contains(string(data), `"schemaVersion"`) || !strings.Contains(string(data), `"daily"`) {
-		t.Fatalf("briefing artifact missing expected fields:\n%s", string(data))
-	}
-}
-
-func TestGenerateBriefingDefaultPath(t *testing.T) {
-	server := dailyBundleServer(t)
-	cfg := dailyTestConfig(t, server)
-	cfg.Workspace.Root = t.TempDir()
-	resolved, err := ResolveGenerate(GenerateRequest{
-		Config: cfg,
-		Report: ReportDaily,
-		Date:   mustParse("2026-05-29T12:00:00-05:00"),
-	}, mustParse("2026-05-29T05:00:00-05:00"))
-	if err != nil {
-		t.Fatalf("ResolveGenerate() error = %v", err)
-	}
-
-	result, err := GenerateBriefing(context.Background(), BriefingRequest{
-		Config:   cfg,
-		Resolved: resolved,
-	})
-	if err != nil {
-		t.Fatalf("GenerateBriefing() error = %v", err)
-	}
-	if !strings.HasSuffix(result.OutputPath, filepath.Join("snapshots", "daily", "2026-05-29", "20260529T100000.000000000Z_daily_today.briefing.json")) {
-		t.Fatalf("OutputPath = %q, want deterministic daily briefing path", result.OutputPath)
-	}
-}
-
 func TestGenerateReportWritesReportAndPreflight(t *testing.T) {
 	server := dailyBundleServer(t)
 	cfg := dailyTestConfig(t, server)
@@ -202,10 +140,10 @@ func TestGenerateReportWritesReportAndPreflight(t *testing.T) {
 	if renderer.runRequest.OutputPath != result.ReportPath {
 		t.Fatalf("run OutputPath = %q, want managed report path %q", renderer.runRequest.OutputPath, result.ReportPath)
 	}
-	if got, want := strings.Join(store.calls, ","), "module_snapshot,briefing,data_package,preflight,metadata,prepare_report,metadata"; !strings.HasPrefix(got, want) {
+	if got, want := strings.Join(store.calls, ","), "module_snapshot,data_package,preflight,metadata,prepare_report,metadata"; !strings.HasPrefix(got, want) {
 		t.Fatalf("store calls = %v, want prefix %s", store.calls, want)
 	}
-	assertPathsExist(t, result.BriefingPath, result.ModuleSnapshotPath, result.DataPackagePath, result.PreflightPath, result.ReportPath, result.MetadataPath, outputPath)
+	assertPathsExist(t, result.ModuleSnapshotPath, result.DataPackagePath, result.PreflightPath, result.ReportPath, result.MetadataPath, outputPath)
 	snapshotData, err := os.ReadFile(result.ModuleSnapshotPath)
 	if err != nil {
 		t.Fatalf("read module snapshot: %v", err)
@@ -257,7 +195,7 @@ func TestGenerateReportWritesReportAndPreflight(t *testing.T) {
 	if result.Metadata.RunID != resolved.Metadata().RunID {
 		t.Fatalf("metadata RunID = %q, want %q", result.Metadata.RunID, resolved.Metadata().RunID)
 	}
-	if result.Metadata.BriefingPath != result.BriefingPath || result.Metadata.ModuleSnapshotPath != result.ModuleSnapshotPath || result.Metadata.DataPackagePath != result.DataPackagePath {
+	if result.Metadata.ModuleSnapshotPath != result.ModuleSnapshotPath || result.Metadata.DataPackagePath != result.DataPackagePath {
 		t.Fatalf("metadata does not link artifact paths: %#v", result.Metadata)
 	}
 	if result.Metadata.RenderedReportPath != result.ReportPath {
@@ -655,8 +593,7 @@ func TestGenerateReportIncludesRecentChangesFromPriorSnapshot(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ResolveGenerate(prior) error = %v", err)
 	}
-	priorBriefing := priorDailyBriefing(priorResolved)
-	savePriorRun(t, store, priorResolved, priorBriefing, priorDailyModuleSnapshot(t, priorResolved))
+	savePriorRun(t, store, priorResolved, priorDailyModuleSnapshot(t, priorResolved))
 
 	currentResolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
@@ -721,14 +658,18 @@ func TestGenerateTomorrowReportUsesTomorrowBriefingDate(t *testing.T) {
 		t.Fatalf("GenerateReport() error = %v", err)
 	}
 
-	if result.Briefing.Metadata.ReportID != report.DailyTomorrow || result.Briefing.Metadata.Variant != "tomorrow" {
-		t.Fatalf("metadata report/variant = %q/%q, want tomorrow", result.Briefing.Metadata.ReportID, result.Briefing.Metadata.Variant)
+	if result.Metadata.ReportID != report.DailyTomorrow || result.Metadata.Variant != "tomorrow" {
+		t.Fatalf("metadata report/variant = %q/%q, want tomorrow", result.Metadata.ReportID, result.Metadata.Variant)
 	}
-	if result.Briefing.Daily.ForecastSummaryDate != "2026-05-30" {
-		t.Fatalf("ForecastSummaryDate = %q, want 2026-05-30", result.Briefing.Daily.ForecastSummaryDate)
+	dailySummary, ok, err := module.StanzaValue[map[string]any](result.ModuleSnapshot, "derived_daily_summary")
+	if err != nil {
+		t.Fatalf("decode daily summary: %v", err)
 	}
-	if result.Briefing.Daily.Planning == nil {
-		t.Fatal("Planning = nil, want tomorrow planning inputs")
+	if !ok || dailySummary["date"] != "2026-05-30" {
+		t.Fatalf("daily summary = %#v, want tomorrow date", dailySummary)
+	}
+	if _, ok := result.ModuleSnapshot.LookupStanza("tomorrow_planning"); !ok {
+		t.Fatal("tomorrow_planning stanza missing")
 	}
 	if !strings.Contains(filepath.Base(result.ReportPath), "daily_tomorrow") {
 		t.Fatalf("ReportPath = %q, want managed tomorrow report path", result.ReportPath)
@@ -753,8 +694,7 @@ func TestTomorrowReportCanCompareAgainstPriorDailySnapshot(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ResolveGenerate(prior) error = %v", err)
 	}
-	priorBriefing := priorDailyBriefing(priorResolved)
-	savePriorRun(t, store, priorResolved, priorBriefing, priorDailyModuleSnapshot(t, priorResolved))
+	savePriorRun(t, store, priorResolved, priorDailyModuleSnapshot(t, priorResolved))
 
 	currentResolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
@@ -803,8 +743,7 @@ func TestGenerateThreeDayReportWritesReportAndRecentChanges(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ResolveGenerate(prior) error = %v", err)
 	}
-	priorBriefing := priorThreeDayBriefing(priorResolved)
-	savePriorRun(t, store, priorResolved, priorBriefing, priorOutlookModuleSnapshot(t, "2026-05-30"))
+	savePriorRun(t, store, priorResolved, priorOutlookModuleSnapshot(t, "2026-05-30"))
 	currentResolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
 		Report: ReportThreeDay,
@@ -828,11 +767,12 @@ func TestGenerateThreeDayReportWritesReportAndRecentChanges(t *testing.T) {
 		t.Fatalf("GenerateReport() error = %v", err)
 	}
 
-	if result.Briefing.ThreeDay == nil {
-		t.Fatal("ThreeDay = nil")
+	dayparts, ok, err := module.StanzaValue[map[string]any](result.ModuleSnapshot, "derived_daypart_summaries")
+	if err != nil {
+		t.Fatalf("decode daypart summaries: %v", err)
 	}
-	if len(result.Briefing.ThreeDay.Days) != 3 {
-		t.Fatalf("ThreeDay days = %d, want 3", len(result.Briefing.ThreeDay.Days))
+	if !ok || len(dayparts) == 0 {
+		t.Fatalf("daypart summaries = %#v, want 3-day module content", dayparts)
 	}
 	if renderer.renderRequest.PromptID != "weather.three_day_outlook" {
 		t.Fatalf("render PromptID = %q, want weather.three_day_outlook", renderer.renderRequest.PromptID)
@@ -862,8 +802,7 @@ func TestGenerateWeekendReportWritesReportAndRecentChanges(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ResolveGenerate(prior) error = %v", err)
 	}
-	priorBriefing := priorWeekendBriefing(priorResolved)
-	savePriorRun(t, store, priorResolved, priorBriefing, priorOutlookModuleSnapshot(t, "2026-05-30"))
+	savePriorRun(t, store, priorResolved, priorOutlookModuleSnapshot(t, "2026-05-30"))
 	currentResolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
 		Report: ReportWeekend,
@@ -887,11 +826,12 @@ func TestGenerateWeekendReportWritesReportAndRecentChanges(t *testing.T) {
 		t.Fatalf("GenerateReport() error = %v", err)
 	}
 
-	if result.Briefing.Weekend == nil {
-		t.Fatal("Weekend = nil")
+	dayparts, ok, err := module.StanzaValue[map[string]any](result.ModuleSnapshot, "derived_daypart_summaries")
+	if err != nil {
+		t.Fatalf("decode daypart summaries: %v", err)
 	}
-	if len(result.Briefing.Weekend.Days) != 3 {
-		t.Fatalf("Weekend days = %d, want 3", len(result.Briefing.Weekend.Days))
+	if !ok || len(dayparts) == 0 {
+		t.Fatalf("daypart summaries = %#v, want weekend module content", dayparts)
 	}
 	if renderer.renderRequest.PromptID != "weather.weekend_outlook" {
 		t.Fatalf("render PromptID = %q, want weather.weekend_outlook", renderer.renderRequest.PromptID)
@@ -936,14 +876,11 @@ func TestGenerateStormReportWritesReport(t *testing.T) {
 		t.Fatalf("GenerateReport() error = %v", err)
 	}
 
-	if result.Briefing.Storm == nil {
-		t.Fatal("Storm = nil")
-	}
 	if renderer.renderRequest.PromptID != "weather.storm_report" {
 		t.Fatalf("render PromptID = %q, want weather.storm_report", renderer.renderRequest.PromptID)
 	}
-	if len(result.Briefing.Storm.HourlyPeriods) == 0 || len(result.Briefing.Storm.NarrativePeriods) == 0 {
-		t.Fatalf("selected source periods hourly/narrative = %d/%d, want relevant periods", len(result.Briefing.Storm.HourlyPeriods), len(result.Briefing.Storm.NarrativePeriods))
+	if _, ok := result.ModuleSnapshot.LookupStanza("precip_timing"); !ok {
+		t.Fatal("precip_timing stanza missing")
 	}
 	if _, err := os.Stat(outputPath); err != nil {
 		t.Fatalf("expected requested report output %q: %v", outputPath, err)
@@ -996,7 +933,7 @@ func TestInspectGeneratedReportArtifacts(t *testing.T) {
 	if err != nil {
 		t.Fatalf("InspectMetadata() error = %v", err)
 	}
-	if metadata.BriefingPath != result.BriefingPath || metadata.ModuleSnapshotPath != result.ModuleSnapshotPath || metadata.DataPackagePath != result.DataPackagePath {
+	if metadata.ModuleSnapshotPath != result.ModuleSnapshotPath || metadata.DataPackagePath != result.DataPackagePath {
 		t.Fatalf("metadata paths = %#v, want generated artifact paths", metadata)
 	}
 	moduleSnapshot, err := InspectModules(context.Background(), InspectRunRequest{Config: cfg, RunID: result.Metadata.RunID})
@@ -1373,43 +1310,8 @@ func assertPathsExist(t *testing.T, paths ...string) {
 	}
 }
 
-func priorDailyBriefing(resolved report.Resolved) briefing.Package {
-	low := 50.0
-	high := 58.0
-	precip := 10.0
-	return briefing.Package{
-		Metadata: briefing.Metadata{
-			SchemaVersion: briefing.SchemaVersion,
-			RunID:         resolved.Metadata().RunID,
-			ReportID:      resolved.Definition.ID,
-			Variant:       "today",
-			PromptID:      resolved.Definition.PromptID,
-			GeneratedAt:   resolved.GeneratedAt,
-			Units:         "us",
-			Timezone:      resolved.Timezone,
-			ValidPeriod:   resolved.ValidPeriod,
-		},
-		Daily: &briefing.Daily{
-			BottomLine: briefing.BottomLine{
-				Temperature: forecast.Range{Min: &low, Max: &high},
-				MaxPrecipProbability: &forecast.TimedValue{
-					Value: precip,
-					Time:  resolved.ValidPeriod.Start.Add(6 * time.Hour),
-				},
-			},
-			Dayparts: []forecast.DaypartSummary{
-				{Name: "morning"},
-			},
-		},
-	}
-}
-
-func savePriorRun(t *testing.T, store state.Store, resolved report.Resolved, briefingPackage briefing.Package, snapshot module.Snapshot) {
+func savePriorRun(t *testing.T, store state.Store, resolved report.Resolved, snapshot module.Snapshot) {
 	t.Helper()
-	briefingPath, err := store.SaveBriefing(context.Background(), resolved, briefingPackage)
-	if err != nil {
-		t.Fatalf("SaveBriefing() error = %v", err)
-	}
 	moduleSnapshotPath, err := store.SaveModuleSnapshot(context.Background(), resolved, snapshot)
 	if err != nil {
 		t.Fatalf("SaveModuleSnapshot() error = %v", err)
@@ -1418,8 +1320,7 @@ func savePriorRun(t *testing.T, store state.Store, resolved report.Resolved, bri
 	if err != nil {
 		t.Fatalf("Paths() error = %v", err)
 	}
-	_, err = store.SaveMetadata(context.Background(), state.BuildMetadata(resolved, briefingPackage, state.ArtifactPaths{
-		Briefing:       briefingPath,
+	_, err = store.SaveMetadata(context.Background(), state.BuildMetadataFromBriefingMetadata(resolved, appBriefingMetadata(resolved), state.ArtifactPaths{
 		ModuleSnapshot: moduleSnapshotPath,
 		Metadata:       paths.Metadata,
 		DataPackage:    paths.DataPackage,
@@ -1480,61 +1381,16 @@ func priorOutlookModuleSnapshot(t *testing.T, date string) module.Snapshot {
 	return snapshot
 }
 
-func priorThreeDayBriefing(resolved report.Resolved) briefing.Package {
-	high := 58.0
-	precip := 10.0
-	return briefing.Package{
-		Metadata: briefing.Metadata{
-			SchemaVersion: briefing.SchemaVersion,
-			RunID:         resolved.Metadata().RunID,
-			ReportID:      resolved.Definition.ID,
-			PromptID:      resolved.Definition.PromptID,
-			GeneratedAt:   resolved.GeneratedAt,
-			Units:         "us",
-			Timezone:      resolved.Timezone,
-			ValidPeriod:   resolved.ValidPeriod,
-		},
-		ThreeDay: &briefing.ThreeDay{
-			Days: []briefing.OutlookDay{
-				{
-					Date:        "2026-05-29",
-					Temperature: forecast.Range{Max: &high},
-					MaxPrecipitationProbability: &forecast.TimedValue{
-						Value: precip,
-						Time:  resolved.ValidPeriod.Start.Add(6 * time.Hour),
-					},
-				},
-			},
-		},
-	}
-}
-
-func priorWeekendBriefing(resolved report.Resolved) briefing.Package {
-	high := 58.0
-	precip := 10.0
-	return briefing.Package{
-		Metadata: briefing.Metadata{
-			SchemaVersion: briefing.SchemaVersion,
-			RunID:         resolved.Metadata().RunID,
-			ReportID:      resolved.Definition.ID,
-			PromptID:      resolved.Definition.PromptID,
-			GeneratedAt:   resolved.GeneratedAt,
-			Units:         "us",
-			Timezone:      resolved.Timezone,
-			ValidPeriod:   resolved.ValidPeriod,
-		},
-		Weekend: &briefing.Weekend{
-			Days: []briefing.OutlookDay{
-				{
-					Date:        "2026-05-30",
-					Temperature: forecast.Range{Max: &high},
-					MaxPrecipitationProbability: &forecast.TimedValue{
-						Value: precip,
-						Time:  resolved.ValidPeriod.Start.Add(12 * time.Hour),
-					},
-				},
-			},
-		},
+func appBriefingMetadata(resolved report.Resolved) briefing.Metadata {
+	return briefing.Metadata{
+		RunID:       resolved.Metadata().RunID,
+		ReportID:    resolved.Definition.ID,
+		Variant:     "today",
+		PromptID:    resolved.Definition.PromptID,
+		GeneratedAt: resolved.GeneratedAt,
+		Units:       "us",
+		Timezone:    resolved.Timezone,
+		ValidPeriod: resolved.ValidPeriod,
 	}
 }
 
@@ -1555,11 +1411,6 @@ type recordingStore struct {
 	calls []string
 }
 
-func (s *recordingStore) SaveBriefing(ctx context.Context, resolved report.Resolved, pkg briefing.Package) (string, error) {
-	s.calls = append(s.calls, "briefing")
-	return s.Store.SaveBriefing(ctx, resolved, pkg)
-}
-
 func (s *recordingStore) SaveModuleSnapshot(ctx context.Context, resolved report.Resolved, snapshot module.Snapshot) (string, error) {
 	s.calls = append(s.calls, "module_snapshot")
 	return s.Store.SaveModuleSnapshot(ctx, resolved, snapshot)