Update default sections of the Area Forecast Discussion provided to different report types

README.md

@@ -9,7 +9,7 @@ Markdown reports to a configured `distributor` HTTP upload endpoint.
 ## Quickstart
 
 ```sh
-weatherreporter generate daily --date 2026-05-29 --out ./daily.md
+weatherreporter generate today --out ./today.md
 ```
 
 ## Documentation

docs/cli.md

@@ -6,27 +6,29 @@ batches, and inspects stored artifacts.
 ## Shortest Useful Command
 
 ```sh
-weatherreporter generate daily --date 2026-05-29 --out ./daily.md
+weatherreporter generate today --out ./today.md
 ```
 
-This loads configuration, fetches weather data, writes managed workspace
-artifacts, runs `scriptorium render` as a preflight check, runs
-`scriptorium run`, and writes an extra Markdown copy to `./daily.md`. If
-distributor notification is enabled in configuration, the command also uploads
-the managed Markdown report after final metadata is saved.
+This loads configuration, collects weather data, writes managed workspace
+artifacts, runs `scriptorium render` as a preflight check, runs structured
+`scriptorium run`, validates generated text, renders the embedded Today
+template, and writes an extra Markdown copy to `./today.md`. If distributor
+notification is enabled in configuration, the command also uploads the managed
+Markdown report after final metadata is saved.
 
 ## Commands
 
 ```text
 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 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
-weatherreporter run morning [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH]
-weatherreporter run evening [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH]
+weatherreporter generate daily --date YYYY-MM-DD [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+weatherreporter generate today [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--date YYYY-MM-DD] [--quiet]
+weatherreporter generate tomorrow [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+weatherreporter generate hourly [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+weatherreporter generate three-day [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+weatherreporter generate weekend [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+weatherreporter generate storm [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet] --start TIME --end TIME
+weatherreporter run morning [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH] [--quiet]
+weatherreporter run evening [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH] [--quiet]
 weatherreporter inspect reports [--config PATH] [--limit N]
 weatherreporter inspect metadata [--config PATH] RUN_ID
 weatherreporter inspect modules [--config PATH] RUN_ID
@@ -35,32 +37,128 @@ weatherreporter inspect prior [--config PATH] RUN_ID
 weatherreporter inspect sources [--config PATH] RUN_ID
 ```
 
-Implemented `generate` commands write a JSON module snapshot, YAML data package,
-preflight artifact, managed Markdown report, and metadata under the configured
-workspace. `--out` writes an extra Markdown copy for the operator; distributor
-notification uses the managed report path, not the extra copy. `generate
-tomorrow` and `generate hourly` write managed generated-text artifacts,
-validate structured text from Scriptorium, and render the managed Markdown
-report from embedded templates. `generate hourly` covers the next six hours in
-the effective report timezone and does not accept date or event window flags.
-`generate storm` requires explicit event-window bounds with `--start` and
-`--end`.
+Implemented `generate` commands emit a compact JSON summary to stdout on
+success. The summary includes command identity, report identity, RunID, status,
+valid period, and managed artifact paths. They also write a JSON module
+snapshot, YAML data package, preflight artifact, managed Markdown report, and
+metadata under the configured workspace. `--out` writes an extra Markdown copy
+for the operator; distributor notification uses the managed report path, not
+the extra copy. `generate daily`,
+`generate today`, `generate tomorrow`, and `generate hourly` write managed
+generated-text artifacts, validate structured text from Scriptorium, and render
+the managed Markdown report from embedded templates. `generate daily` requires
+`--date YYYY-MM-DD` for the selected local civil day; omitting `--date` is a
+command error and stops before weather data is collected. `generate hourly`
+covers the next six hours in the effective report timezone and does not accept
+date or event window flags. `generate storm` requires explicit event-window
+bounds with `--start` and `--end`.
 
-`run morning` generates Daily Today and the 3-Day Outlook, plus Weekend Outlook
-except on Sunday. `run evening` generates the Tomorrow Report. Batch
-runs continue independent reports after a failure, print a JSON summary to
-stdout, write compact status lines to stderr, and return nonzero when any report
-failed. `--out-dir` writes extra Markdown copies for the operator; distributor
-notification uses each managed report path, not the extra copies. When
-notification is enabled, batch summaries and status lines include notification
-status, accepted distributor run ID, or notification error fields for each
-attempted report.
+`run morning` generates Today Report, Tomorrow Report, and a dated Daily Report
+for each later future local civil day with complete hourly forecast coverage.
+`run evening` generates Tomorrow Report and the same eligible future Daily
+reports. Future Daily expansion starts with the day after tomorrow and skips
+days that do not have every hourly forecast period for the local civil day.
+Batch commands collect weather data once before planning; a collection failure
+stops the batch before any report is generated. Batch runs continue independent
+reports after a later report failure, print a JSON summary to stdout, write
+compact status lines to stderr, and return nonzero when any report failed.
+`--out-dir` writes extra Markdown copies for the operator; distributor
+notification uses managed report paths, not the extra copies. Today and
+Tomorrow use their report default copy names, and dynamic Daily copies use
+`daily-YYYY-MM-DD.md`. When distributor and batch notification are enabled, a
+fully successful batch uploads one distributor bundle after report generation
+finishes. The JSON summary exposes that upload as a top-level `notification`
+object, and stderr includes one `batchNotification` status line. If any planned
+report fails, the batch notification is skipped for the whole batch.
 
-Hourly Report is explicit only; it is not included in `run morning` or `run
-evening`.
+Hourly Report, 3-Day Outlook, and Weekend Outlook are explicit only; they are
+not included in `run morning` or `run evening`.
 
-`inspect` commands read existing workspace artifacts and emit JSON to stdout.
-They do not fetch weather data or invoke `scriptorium`.
+`inspect` commands read existing workspace artifacts and emit the requested
+JSON data to stdout. They do not collect weather data or invoke `scriptorium`.
+Inspection commands do not accept `--quiet`.
+
+## Output
+
+Action commands, meaning `generate` and `run`, emit JSON summaries to stdout by
+default. Pre-run errors, such as invalid flags, missing required arguments, or
+configuration load failures, return an error without emitting partial JSON.
+`--quiet` suppresses successful action-command stdout and routine stderr. It
+does not hide returned errors. Inspection commands are data-output commands;
+they always write the requested JSON to stdout and are not quietable.
+
+Generate summaries have this shape:
+
+```json
+{
+  "command": "generate",
+  "reportId": "today",
+  "reportName": "Today Report",
+  "promptId": "weather.today_generated_text",
+  "runId": "20260529T120000.000000000Z_today",
+  "status": "succeeded",
+  "generatedAt": "2026-05-29T12:00:00Z",
+  "validPeriod": {
+    "start": "2026-05-29T00:00:00-05:00",
+    "end": "2026-05-30T00:00:00-05:00"
+  },
+  "reportPath": "workspace/reports/today/2026-05-29/report.20260529T120000.000000000Z_today.md",
+  "metadataPath": "workspace/snapshots/today/2026-05-29/metadata.20260529T120000.000000000Z_today.json",
+  "dataPackagePath": "workspace/data-packages/today/2026-05-29/data_package.20260529T120000.000000000Z_today.yaml",
+  "preflightPath": "workspace/preflight/today/2026-05-29/render.20260529T120000.000000000Z_today.json",
+  "generatedTextRawPath": "workspace/snapshots/today/2026-05-29/generated_text_raw.20260529T120000.000000000Z_today.json",
+  "generatedTextResultPath": "workspace/snapshots/today/2026-05-29/generated_text_result.20260529T120000.000000000Z_today.json",
+  "generatedTextPath": "workspace/snapshots/today/2026-05-29/generated_text.20260529T120000.000000000Z_today.json",
+  "renderContextPath": "workspace/snapshots/today/2026-05-29/render_context.20260529T120000.000000000Z_today.json"
+}
+```
+
+Markdown-path reports omit the generated-text fields. If distributor
+notification is attempted, summaries include `notificationPath`; successful
+notification also includes a compact `notification` object. If notification
+fails after report artifacts exist, the summary has `"status": "failed"` and an
+`error` string while retaining inspectable artifact paths.
+
+Run summaries have this shape:
+
+```json
+{
+  "command": "run",
+  "batch": "morning",
+  "status": "succeeded",
+  "startedAt": "2026-05-29T12:00:00Z",
+  "finishedAt": "2026-05-29T12:01:00Z",
+  "total": 1,
+  "succeeded": 1,
+  "failed": 0,
+  "reports": [
+    {
+      "reportId": "today",
+      "reportName": "Today Report",
+      "promptId": "weather.today_generated_text",
+      "runId": "20260529T120000.000000000Z_today",
+      "status": "succeeded",
+      "generatedAt": "2026-05-29T12:00:00Z",
+      "validPeriod": {
+        "start": "2026-05-29T00:00:00-05:00",
+        "end": "2026-05-30T00:00:00-05:00"
+      },
+      "reportPath": "workspace/reports/today/2026-05-29/report.20260529T120000.000000000Z_today.md",
+      "metadataPath": "workspace/snapshots/today/2026-05-29/metadata.20260529T120000.000000000Z_today.json",
+      "dataPackagePath": "workspace/data-packages/today/2026-05-29/data_package.20260529T120000.000000000Z_today.yaml",
+      "preflightPath": "workspace/preflight/today/2026-05-29/render.20260529T120000.000000000Z_today.json"
+    }
+  ]
+}
+```
+
+`run` status is `failed` when any report failed or the top-level batch
+notification failed. Batch stderr uses compact status lines, for example:
+
+```text
+report=today status=succeeded output="reports/today.md"
+batch=morning total=2 succeeded=2 failed=0
+```
 
 ## Flags
 
@@ -70,7 +168,8 @@ They do not fetch weather data or invoke `scriptorium`.
 - `--tz NAME`: override configured Weather API timezone for `generate` and `run`.
 - `--out PATH`: write an extra Markdown report copy where supported by the `generate` command.
 - `--out-dir PATH`: write extra Markdown report copies for `run morning` and `run evening`.
-- `--date YYYY-MM-DD`: optional date for `generate daily`; defaults to the current local date in the configured timezone.
+- `--quiet`: suppress successful stdout and routine stderr for `generate` and `run`.
+- `--date YYYY-MM-DD`: required date for `generate daily`; optional date for `generate today`, defaulting to the current local date in the configured timezone.
 - `--start TIME`: required start time for `generate storm`.
 - `--end TIME`: required end time for `generate storm`.
 - `--limit N`: maximum records for `inspect reports`; defaults to `20`, and `0` means no limit.
@@ -84,6 +183,8 @@ are no distributor-specific CLI flags.
 ## Common Workflows
 
 ```sh
+weatherreporter generate today --out ./today.md
+weatherreporter generate daily --date 2026-05-29 --out ./daily.md
 weatherreporter generate tomorrow --out ./tomorrow.md
 weatherreporter generate hourly
 weatherreporter generate three-day --out ./three-day.md
@@ -91,17 +192,20 @@ weatherreporter generate weekend --out ./weekend.md
 weatherreporter generate storm --start 2026-05-29T18:00 --end 2026-05-30T06:00 --out ./storm.md
 weatherreporter run morning --out-dir ./reports
 weatherreporter run evening --out-dir ./reports
+weatherreporter generate today --quiet
+weatherreporter run morning --quiet
 ```
 
 ## Inspection
 
 ```sh
 weatherreporter inspect reports --limit 10
-weatherreporter inspect metadata 20260529T100000.000000000Z_daily_today
-weatherreporter inspect modules 20260529T100000.000000000Z_daily_today
-weatherreporter inspect data-package 20260529T100000.000000000Z_daily_today
-weatherreporter inspect prior 20260529T100000.000000000Z_daily_today
-weatherreporter inspect sources 20260529T100000.000000000Z_daily_today
+weatherreporter inspect metadata 20260529T100000.000000000Z_today
+weatherreporter inspect modules 20260529T100000.000000000Z_today
+weatherreporter inspect data-package 20260529T100000.000000000Z_today
+weatherreporter inspect prior 20260529T100000.000000000Z_today
+weatherreporter inspect sources 20260529T100000.000000000Z_today
+weatherreporter inspect metadata 20260529T100000.000000000Z_daily
 ```
 
 `inspect reports` lists recent generated runs with artifact paths and source

docs/config.md

@@ -29,8 +29,8 @@ weather_api:
   base_url: https://weather.api.example.com/
 ```
 
-`weather_api.base_url` is required for commands that fetch weather data. Other
-fields fall back to defaults.
+`weather_api.base_url` is required for commands that collect weather data.
+Other fields fall back to defaults.
 
 ## Production-Oriented Config
 
@@ -41,7 +41,7 @@ config test suite.
 
 ### `weather_api`
 
-- `base_url`: absolute base URL for the Weather API. Required for generation and fetch workflows.
+- `base_url`: absolute base URL for the Weather API. Required for generation and collection workflows.
 - `timeout`: HTTP timeout duration. Default: `10s`.
 - `precision`: numeric precision query value. Default: `1`.
 - `units`: Weather API units query value. Default: `us`.
@@ -78,10 +78,13 @@ missing directories, and unreadable files fail config loading.
 
 ### `notify`
 
-`notify.distributor` controls distributor notification after successful report
-generation. It is disabled by default and does not add CLI flags. When enabled,
-weatherreporter uploads one distributor bundle per generated report after
-report rendering succeeds and final metadata is saved.
+`notify.distributor` controls distributor uploads after successful report
+rendering. It is disabled by default and does not add CLI flags. When enabled,
+`generate <report>` uploads one distributor bundle for the generated report
+after final metadata is saved. `run morning` and `run evening` use
+`notify.distributor.batch`: when batch notification is enabled and every
+planned report succeeds, weatherreporter uploads one distributor bundle that
+contains all managed Markdown reports from that batch.
 
 - `enabled`: whether distributor notification config is active. Default:
   `false`.
@@ -92,33 +95,63 @@ report rendering succeeds and final metadata is saved.
 - `timeout`: distributor operation timeout. Must be greater than zero when
   enabled. Default: `30s`.
 - `failure_policy`: must be `error` when enabled. Default: `error`.
-- `pipeline_id_template`: template for the distributor pipeline ID. Required
-  when enabled. Default: empty.
-- `bundle_id_template`: template for distributor bundle IDs. Default:
-  `weatherreporter.{location_id}.{report_id}`.
-- `idempotency_key_template`: template for distributor idempotency keys.
-  Default: `{bundle_id}.{run_id}`.
-- `report_path_templates`: ordered list of templates for Markdown report paths
-  inside the distributor bundle. Each rendered path maps to the same managed
-  Markdown report source. Default:
-  ```yaml
-  - "{valid_start_date}/{artifact_group}/{valid_start_date}-{artifact_group}-{run_id}.md"
-  ```
+- `pipeline_id_template`: template for single-report distributor pipeline IDs.
+  Required when enabled. Default: empty.
+- `bundle_id_template`: template for single-report distributor bundle IDs.
+  Default: `weatherreporter.{location_id}.{report_id}`.
+- `idempotency_key_template`: template for single-report distributor
+  idempotency keys. Default: `{bundle_id}.{run_id}`.
+- `batch.enabled`: whether batch distributor notification config is active
+  when distributor notification is enabled. Default: `true`.
+- `batch.pipeline_id_template`: template for batch distributor pipeline IDs.
+  Required when distributor notification and batch notification are enabled.
+  Default: `weatherreporter`.
+- `batch.bundle_id_template`: template for batch distributor bundle IDs.
+  Required when distributor notification and batch notification are enabled.
+  Default: `weatherreporter.{location_id}.{batch}`.
+- `batch.idempotency_key_template`: template for batch distributor idempotency
+  keys. Required when distributor notification and batch notification are
+  enabled. Default: `{bundle_id}.{batch_run_id}`.
 
-Supported template variables are `location_id`, `report_id`, `run_id`,
+Single-report templates support `location_id`, `report_id`, `run_id`,
 `artifact_group`, `batch_output_name`, `valid_start_date`, `valid_end_date`,
-`valid_start_time`, `valid_end_time`, `valid_start_stamp`, and
-`valid_end_stamp`. Date values use `YYYY-MM-DD`, time values use `HHMM`, and
+`valid_start_time`, `valid_end_time`, `valid_start_stamp`, `valid_end_stamp`,
+and `storm_id`. Date values use `YYYY-MM-DD`, time values use `HHMM`, and
 stamp values use `YYYY-MM-DDTHHMM` in the effective report timezone.
-`pipeline_id_template` and `idempotency_key_template` may also use `bundle_id`.
+`storm_id` is derived from the storm report valid period as
+`{valid_start_stamp}-{valid_end_stamp}`; it renders empty for non-storm
+reports. `pipeline_id_template` and `idempotency_key_template` may also use
+`bundle_id`.
 
 The rendered pipeline ID selects the configured distributor `http_upload`
 workflow. The rendered bundle ID is the stable logical source identity for the
 report stream. The rendered idempotency key is the per-run retry identity.
 
+Batch templates support `location_id`, `batch`, `batch_run_id`, and
+`batch_started_date`. Batch idempotency templates may also use `bundle_id`.
+`batch_started_date` is the batch start date in the effective report timezone.
+Batch bundle IDs identify a logical batch stream; batch idempotency keys
+identify a specific retryable batch attempt.
+
 Rendered report paths must be unique relative paths with `/` separators. They
 must not contain backslashes, empty path segments, `.`, `..`, `manifest.json`,
-or `.distributor.json`.
+or the reserved distributor sidecar basename, formed from a leading dot plus
+`distributor.json`. In a batch upload, uniqueness is checked across every
+rendered bundle path for every included report before distributor is called.
+Managed Markdown report paths are the only upload source files; copies written
+with `--out` or `--out-dir` are never uploaded.
+
+Distributor bundle paths are report-specific. Weatherreporter uses
+`reports.<report>.distributor.path_templates` when that override is configured;
+otherwise it uses the report definition defaults:
+
+- `hourly`: `hourly/index.md`
+- `daily`: `daily/{valid_start_date}/{run_id}.md`, `daily/{valid_start_date}/index.md`
+- `today`: `daily/{valid_start_date}/{run_id}.md`, `daily/{valid_start_date}/index.md`, `today/index.md`
+- `tomorrow`: `daily/{valid_start_date}/{run_id}.md`, `daily/{valid_start_date}/index.md`, `tomorrow/index.md`
+- `three_day`: `three-day/{valid_start_date}/{run_id}.md`, `three-day/{valid_start_date}/index.md`
+- `weekend`: `weekend/{valid_start_date}/{run_id}.md`, `weekend/{valid_start_date}/index.md`
+- `storm`: `storm/{storm_id}/{run_id}.md`, `storm/{storm_id}/index.md`
 
 The upload token is read from the environment variable named by `token_env`
 after config loading and `secrets.directory` processing. Config files should
@@ -152,7 +185,9 @@ the missing-source policy. Source override keys include `observations`,
 - `notifications_dir`: distributor notification debug artifact directory under `workspace.root`. Default: `notifications`.
 
 Workspace subdirectories must be relative paths that stay inside
-`workspace.root`.
+`workspace.root`. Managed artifact paths below those directories are grouped by
+artifact group and valid-period start date; the path template is not
+configurable.
 
 ### `dayparts`
 
@@ -181,20 +216,32 @@ snapshot exists and a threshold is crossed.
 `reports` optionally overrides the ordered deterministic modules declared by
 report definitions. Omit a report entry to use its default module order.
 
-Supported report keys are `daily`, `tomorrow`, `hourly`, `three_day`,
-`weekend`, and `storm`. Canonical report IDs such as `daily_today` are also
-accepted.
+Supported report keys are `daily`, `today`, `tomorrow`, `hourly`,
+`three_day`, `weekend`, and `storm`. Canonical report IDs and accepted aliases
+are also valid, including `three_day_outlook`, `weekend_outlook`, and
+`storm_report`. Hyphens and underscores are treated equivalently in report
+keys. Retired report keys are not supported.
+
+`reports.today` applies only to the Today Report. `reports.daily` applies only
+to the dated Daily Report.
 
 Each report entry supports:
 
 - `deterministic_modules`: ordered module list. Entries may be string module
   IDs or objects with `id` and optional `options`.
+- `distributor.path_templates`: optional ordered distributor bundle path
+  templates for this report. If omitted, the report definition defaults are
+  used. If present, the list must contain at least one template.
 
 Example:
 
 ```yaml
 reports:
   daily:
+    distributor:
+      path_templates:
+        - "daily/{valid_start_date}/{run_id}.md"
+        - "daily/{valid_start_date}/index.md"
     deterministic_modules:
       - metadata
       - current_conditions
@@ -204,9 +251,26 @@ reports:
       - id: area_forecast_discussion
         options:
           sections:
-            - short_term
+            - long_term
       - spc_convective_discussion
+      - daily_planning
       - hourly_forecast
+  today:
+    deterministic_modules:
+      - metadata
+      - current_conditions
+      - narrative_forecast
+      - derived_daily_summary
+      - derived_daypart_summaries
+      - precip_timing
+      - alert_digest
+      - spc_convective_outlooks
+      - area_forecast_discussion
+      - spc_convective_discussion
+      - weather_story
+      - outdoor_windows
+      - hourly_forecast
+      - today_planning
   hourly:
     deterministic_modules:
       - metadata
@@ -228,7 +292,8 @@ Unknown reports, unknown modules, duplicate modules, incompatible report/module
 combinations, duplicate stanza names, and invalid options fail config loading.
 `area_forecast_discussion.options.sections` may contain `product`,
 `key_messages`, `short_term`, and `long_term`. Empty or omitted `sections`
-includes all available AFD sections.
+includes all available AFD sections. Default report definitions may choose a
+smaller report-specific subset, such as daily reports using only `long_term`.
 
 The module registry accepts all module IDs documented in
 [Module Contract Internals](internal/module.md). Unknown or unimplemented

docs/integrations/distributor/api.md

@@ -104,7 +104,7 @@ func SubmitReport(reportPath, summaryPath string) error {
 - Keep file contents stable after upload inputs are selected. Bundle digests are calculated from file bytes.
 - Treat upload success as admission only. `UploadFiles` and `UploadBundle` return after the server accepts and validates the upload, not after all destinations publish.
 
-Valid bundle paths are relative slash paths. They must not be empty, absolute, contain backslashes, contain `.` or `..` path segments, contain empty path segments, or use reserved basenames `manifest.json` or `.distributor.json`.
+Valid bundle paths are relative slash paths. They must not be empty, absolute, contain backslashes, contain `.` or `..` path segments, contain empty path segments, or use reserved basenames such as `manifest.json` and the distributor sidecar basename formed from a leading dot plus `distributor.json`.
 
 ## Idempotency And Status
 

docs/integrations/distributor/pkg-bundle.md

@@ -68,7 +68,8 @@ Invalid paths include:
 - paths containing backslashes;
 - `.` or `..` path segments;
 - empty path segments;
-- any basename of `manifest.json` or `.distributor.json`.
+- any reserved basename, including `manifest.json` and the distributor sidecar
+  basename formed from a leading dot plus `distributor.json`.
 
 Explicit file lists preserve caller order. File order is part of the bundle digest, so producers should choose it deliberately and keep it stable.
 

docs/internal/app-orchestration.md

@@ -5,11 +5,12 @@ This document describes the workflow coordinator in `internal/app`.
 ## Purpose
 
 `internal/app` coordinates the top-level use cases after CLI parsing and config
-loading are complete. It resolves report definitions, fetches weather data,
-builds collected and derived facts, builds module snapshots and prompt-input
-artifacts, invokes Scriptorium through the adapter boundary, optionally
-notifies distributor through an app-owned notifier boundary, persists managed
-state, runs batches, and reads existing artifacts for inspection.
+loading are complete. It resolves report definitions, collects weather data
+through `internal/collect`, builds collected and derived facts, builds module
+snapshots and prompt-input artifacts, invokes Scriptorium through the adapter
+boundary, optionally notifies distributor through an app-owned notifier
+boundary, persists managed state, runs batches, and reads existing artifacts
+for inspection.
 
 ## Inputs And Outputs
 
@@ -17,12 +18,12 @@ Inputs:
 
 - `GenerateRequest` for one report command
 - `BatchRequest` for morning or evening batch commands
-- `FetchBundleRequest` for explicit bundle fetch and save workflows
+- `FetchBundleRequest` for explicit bundle collection and save workflows
 - `ReportRequest` for single-report generation
 - resolved report definitions from `internal/report`
-- weather data bundles from `internal/adapters/weatherapi`
+- collection results from `internal/collect`
 - prior snapshots loaded from `internal/state`
-- optional renderer, notifier, and state-store fakes for tests
+- optional collector, renderer, notifier, and state-store fakes for tests
 
 Outputs:
 
@@ -31,8 +32,8 @@ Outputs:
   result details, generated-text artifact paths when applicable, and
   notification result when attempted
 - batch summaries with per-report status, artifact paths, error text, and
-  notification outcome when attempted
-- saved Weather API bundle JSON for fetch workflows
+  one top-level batch notification result when attempted or skipped
+- saved Weather API bundle JSON for explicit bundle collection workflows
 - inspection JSON values for reports, metadata, module snapshots, data
   packages, prior snapshots, and source provenance
 
@@ -45,15 +46,18 @@ construct Scriptorium argv.
 
 Report selection and report identity policy come from `internal/report`.
 Collected and derived fact contracts come from `internal/facts`.
-Weather API transport stays in `internal/adapters/weatherapi`. Scriptorium
-subprocess behavior stays in `internal/adapters/scriptorium`. Distributor
-upload behavior stays in `internal/adapters/distributor`. Filesystem layout and
-persisted metadata stay in `internal/state`.
+Weather API transport stays in `internal/adapters/weatherapi`, and app-facing
+upstream collection stays in `internal/collect`. Scriptorium subprocess
+behavior stays in `internal/adapters/scriptorium`. Distributor upload behavior
+stays in `internal/adapters/distributor`. Filesystem layout and persisted
+metadata stay in `internal/state`.
 
 ## Data Flow Terms
 
-- `CollectedFacts` are normalized source facts fetched once from Weather API
-  and made available to derivation and module builders.
+- `collect.Result` is the app-facing upstream collection result. It carries the
+  normalized `weatherdata.Bundle` used by report generation.
+- `CollectedFacts` are normalized source facts derived from a collected Weather
+  API bundle and made available to derivation and module builders.
 - `DerivedFacts` are deterministic calculations over collected facts, the
   resolved valid period, daypart configuration, and report-specific windows.
 - `module.Output` values are ordered deterministic stanzas built from collected
@@ -70,56 +74,61 @@ persisted metadata stay in `internal/state`.
 - `workspace.*` for filesystem state
 - `dayparts` for daily and outlook summarization
 - `recent_change.*` for structured Recent Changes thresholds
-- `notify.distributor.*` for optional notification after report generation
+- `notify.distributor.*` for optional single-report and batch notification
+  after report generation
 
 Output copy flags are command request fields. They are not configuration
 defaults.
 
 ## Generation Workflow
 
-Single-report generation shares this setup:
+Single-report commands validate the report command, collect once through
+`internal/collect`, resolve the requested report, and pass the resolved report
+plus explicit collection into `GenerateReport`. `GenerateDetailed` returns the
+resulting `ReportResult`; `Generate` wraps the same workflow for error-only
+callers.
 
-1. Resolve the command report to a `report.Resolved` value.
-2. Create or use a filesystem store.
-3. Locate any prior compatible snapshot through `internal/state`.
-4. Fetch a Weather API bundle.
-5. Build collected and derived facts once.
-6. Execute configured modules and save the module snapshot.
-7. Compute Recent Changes from structured prior and current module snapshots.
-8. Build and save the YAML Scriptorium `data_package`.
-9. Run Scriptorium render preflight.
-10. Save preflight JSON when a render result is available.
-11. Save metadata for inspection.
+`GenerateReport` then uses this setup:
+
+1. Create or use a filesystem store.
+2. Locate any prior compatible snapshot through `internal/state`.
+3. Build collected and derived facts from the supplied collection.
+4. Execute configured modules and save the module snapshot.
+5. Compute Recent Changes from structured prior and current module snapshots.
+6. Build and save the YAML Scriptorium `data_package`.
+7. Run Scriptorium render preflight.
+8. Save preflight JSON when a render result is available.
+9. Save metadata for inspection.
 
 For `scriptorium_markdown` reports, generation then:
 
-12. Runs Scriptorium report generation to the managed report path.
-13. Copies the managed report to the requested `--out` path when provided.
-14. Saves metadata with the managed report path.
-15. If distributor notification is enabled, notifies using the managed report
-    path as the source file.
-16. Saves a distributor notification debug artifact and updates metadata with
-    its path.
+10. Runs Scriptorium report generation to the managed report path.
 
 For `generated_text_template` reports, generation then:
 
-12. Runs structured Scriptorium generation to the raw generated-text JSON path.
-13. Saves the structured Scriptorium run result.
-14. Validates and saves normalized generated text.
-15. Builds and saves a typed render context.
-16. Renders Markdown from the embedded template to the managed report path.
-17. Saves final metadata with generated-text paths, render context path, schema
-    ID, and managed report path.
-18. Copies the managed report to the requested `--out` path when provided.
-19. If distributor notification is enabled, notifies using the managed report
+10. Looks up the generated-text catalog entry for the report schema/template
+    IDs.
+11. Runs structured Scriptorium generation to the raw generated-text JSON path.
+12. Saves the structured Scriptorium run result.
+13. Validates and saves normalized generated text.
+14. Builds and saves a typed render context.
+15. Renders Markdown from the embedded template to the managed report path.
+
+After either mode has produced a managed Markdown report, shared finalization:
+
+1. Copies the managed report to the requested `--out` or `--out-dir` path when
+   provided.
+2. Saves final metadata with the managed report path and any generated-text
+   artifact paths already produced.
+3. If distributor notification is enabled, notifies using the managed report
    path as the source file.
-20. Saves a distributor notification debug artifact and updates metadata with
+4. Saves a distributor notification debug artifact and updates metadata with
    its path.
 
 If render preflight returns both a result and an error, preflight JSON and
 metadata are persisted before the error is returned. If Scriptorium report
 generation returns an error after writing output, the managed report and
-metadata remain inspectable. Notification is not attempted after Weather API,
+metadata remain inspectable. Notification is not attempted after collection,
 module snapshot, prompt input, render, Scriptorium run, or metadata-save
 failures.
 Generated-text report failures are returned with report ID, RunID, and the
@@ -134,15 +143,38 @@ failure context.
 
 ## Batch Workflow
 
-`run morning` resolves Daily Today, 3-Day Outlook, and Weekend Outlook except
-on Sunday. `run evening` resolves Tomorrow Report. Batch output copy names come
-from report definitions. Batch generation continues independent reports after a
+`run morning` collects once, plans Today Report, Tomorrow Report, and eligible
+future Daily Reports from the collected hourly forecast, then passes the same
+collection into each report generation. `run evening` uses the same collection
+and planning rules, but starts with Tomorrow Report. Future Daily reports start
+with the day after tomorrow and require complete hourly forecast coverage for
+the target local civil day. Dynamic Daily `--out-dir` copies use
+`daily-YYYY-MM-DD.md`; other batch copies use report definition output names.
+A collection failure stops the batch before planning or report generation.
+After planning succeeds, batch generation continues independent reports after a
 failure, records each result, writes compact status lines to stderr, emits a
 JSON summary to stdout, and returns an aggregate error when any report failed.
-When notification is enabled, each successfully generated report is notified
-independently. Notification failure marks that report failed, records
-notification fields in the batch result, and does not stop later reports.
-`--out-dir` copies are never used as notification source files.
+
+Batch report generation suppresses per-report distributor notification. After
+all planned reports finish, app orchestration evaluates batch notification:
+
+1. If distributor notification is disabled, the batch notification result is
+   omitted.
+2. If batch notification is disabled, the batch notification result is omitted
+   and there is no per-report fallback upload.
+3. If any planned report failed, the batch notification result is `skipped`
+   with reason `one or more reports failed`, and distributor is not called.
+4. If every report succeeded, app orchestration renders batch pipeline, bundle
+   ID, and idempotency key templates, renders report-specific distributor
+   paths for each included report, validates every managed source path and
+   bundle path, checks duplicate bundle paths across the batch, calls the
+   notifier once with a multi-file request, and saves a batch notification
+   debug artifact.
+
+Batch notification failure records a top-level failed notification, increments
+the aggregate batch failure count, and returns an aggregate batch error without
+marking individual report items failed. `--out-dir` copies are never used as
+notification source files.
 
 ## Inspection Workflow
 
@@ -153,15 +185,19 @@ inspection view.
 
 ## Failure Behavior
 
-- Resolve errors stop the requested workflow before fetching weather data.
-- Weather API and module execution errors stop that report before Scriptorium
+- Resolve errors stop the requested workflow before collection.
+- Collection and module execution errors stop that report before Scriptorium
   runs.
 - Prompt input validation fails before render preflight.
 - Render and run errors preserve Scriptorium stderr and exit-code context.
 - Generated-text report errors preserve available intermediate artifacts and do
   not create extra output copies.
-- Notification errors are wrapped with report ID, RunID, and managed report path
-  context and are recorded separately in batch results.
+- Single-report notification errors are wrapped with report ID, RunID, and
+  managed report path context. Detailed generation returns the inspectable
+  report, metadata, and notification artifact paths when finalization has
+  already saved them.
+- Batch notification errors are recorded on the top-level batch notification
+  result and do not change individual report item status.
 - Metadata and artifact path errors include filesystem context.
 - Batch failures are recorded per report and surfaced through an aggregate
   batch error.
@@ -171,12 +207,17 @@ inspection view.
 Inspect:
 
 - `internal/app/app_test.go`
+- `internal/app/batch_plan_test.go`
+- `internal/collect/collect_test.go`
 - `internal/cli/root_test.go`
 - `internal/state/filesystem_test.go`
 
 ## Invariants
 
 - Report behavior is resolved through `internal/report`.
+- Generate and run commands collect once before report generation.
+- Batch planning is app-owned because future Daily membership depends on
+  collected hourly forecast coverage.
 - Generated reports use the same app request and result types regardless of
   report ID.
 - Render preflight precedes Scriptorium report generation.
@@ -184,5 +225,9 @@ Inspect:
   a raw data package.
 - Recent Changes are computed from structured module snapshots.
 - Metadata links artifacts produced for a run.
-- Distributor notification maps the managed Markdown report path to configured
-  bundle paths; extra output copies are not upload sources.
+- Single-report distributor notification maps the managed Markdown report path
+  to configured bundle paths.
+- Batch distributor notification maps each included managed Markdown report
+  path to bundle paths rendered for that report and uploads once for the
+  batch.
+- Extra output copies are not upload sources.

docs/internal/briefing.md

@@ -33,22 +33,40 @@ Outputs:
   `weather_story`
 - `module.Output` values for derived stanzas:
   `derived_daily_summary`, `derived_daypart_summaries`, `precip_timing`,
-  `outdoor_windows`, and `tomorrow_planning`
+  `outdoor_windows`, `today_planning`, `tomorrow_planning`, and
+  `daily_planning`
 
 Every registered composition entry has a builder. Unknown or unimplemented
 module IDs fail validation instead of being skipped.
 
+Daily Report supports the Daily-style civil-day modules plus `daily_planning`
+and `hourly_forecast`; those outputs feed the dated Daily GeneratedText prompt
+package and embedded Markdown template.
+
 Tomorrow Report supports the Daily-style civil-day modules plus
 `tomorrow_planning` and `hourly_forecast`; those outputs feed the Tomorrow
 GeneratedText prompt package and embedded Markdown template.
 
+Today Report supports the Daily-style civil-day modules plus `today_planning`
+and `hourly_forecast`; those outputs feed the Today GeneratedText prompt
+package and embedded Markdown template.
+
+`today_planning` is a Today-specific deterministic planning stanza with
+morning readiness, commute/school/workday concerns, outdoor planning, and
+late-day change-watch fields. It is compatible with `report.Today` only.
+
+`daily_planning` is a dated Daily deterministic planning stanza with morning
+readiness, commute/school/workday concerns, and overnight change-watch fields.
+It is compatible only with the `daily` report ID value. The default Daily
+Report composition includes it.
+
 Hourly Report supports source and valid-period modules that operate over its
 rolling six-hour period: `metadata`, `current_conditions`, `hourly_forecast`,
 `precip_timing`, `alert_digest`, `spc_convective_outlooks`,
 `area_forecast_discussion`, `spc_convective_discussion`, and `weather_story`.
 It does not support daily/daypart-only modules such as
-`derived_daily_summary`, `derived_daypart_summaries`, `outdoor_windows`, or
-`tomorrow_planning`.
+`derived_daily_summary`, `derived_daypart_summaries`, `outdoor_windows`,
+`today_planning`, `tomorrow_planning`, or `daily_planning`.
 
 Prompt-facing module values use local, human-readable date and time labels
 where the LLM is expected to reason about report content. Canonical timestamps
@@ -59,7 +77,7 @@ remain in report metadata, source provenance, and integration artifacts.
 - This package selects and shapes already-collected weather facts for prompts.
 - It validates module composition against report compatibility and option
   types.
-- It does not fetch weather data, compare prior snapshots, write module
+- It does not collect weather data, compare prior snapshots, write module
   snapshots, build YAML data packages, invoke Scriptorium, or write workflow
   metadata.
 
@@ -72,14 +90,16 @@ builders run. Configured `location` values are prompt context only; Weather API
 
 `area_forecast_discussion` uses optional `sections` configuration to include a
 subset of discussion fields. Hourly Report defaults this module to
-`key_messages` and `short_term`.
+`key_messages` and `short_term`; Daily Report defaults it to `long_term`.
 
 `spc_convective_outlooks` uses collected SPC run metadata and derived
 report-period outlooks. It emits `checked: true` for a successfully fetched
 empty run, reports `outlook_count`, and includes prompt-facing outlook fields
 such as risk label, `period_begins`, `period_ends`, image URL, and whether the
-outlook contains the configured location. It does not emit GeoJSON geometry,
-source URL, expiration time, or severity rank.
+outlook contains the configured location. It also emits a curated `risk_digest`
+for categorical outlooks that overlap the report period, contain the location,
+and meet the configured-in-code minimum severity for report rendering. It does
+not emit GeoJSON geometry, source URL, expiration time, or severity rank.
 
 Prompt-facing module intervals use friendly local `period_begins` and
 `period_ends` labels. Canonical report metadata, source provenance,

docs/internal/cli.md

@@ -0,0 +1,67 @@
+# CLI Internals
+
+This document describes command output ownership in `internal/cli`.
+
+## Purpose
+
+`internal/cli` owns command parsing, app request construction, help text, and
+presentation of command results. It converts app-layer results into stable CLI
+summaries and writes stdout/stderr through shared output helpers.
+
+## Command Categories
+
+- Action commands: `generate` and `run`. These perform work, write artifacts,
+  and return compact summaries.
+- Inspection commands: `inspect reports`, `inspect metadata`, `inspect
+  modules`, `inspect data-package`, `inspect prior`, and `inspect sources`.
+  These read existing artifacts and return requested data.
+
+Future commands must declare which category they belong to before adding output
+behavior.
+
+## Stdout And Stderr
+
+Action commands write JSON summaries to stdout by default. `run` also writes
+compact status lines to stderr through `writeBatchStatus`. `generate` does not
+write routine stderr today. Pre-run errors return without partial JSON.
+
+Inspection commands write requested JSON data to stdout with `writeJSON`. They
+do not use action output helpers and do not support quiet mode.
+
+Returned errors are not hidden by output helpers. The caller remains
+responsible for displaying command errors.
+
+## Quiet Mode
+
+`--quiet` is supported only by action commands. It suppresses successful stdout
+and routine stderr by passing `outputOptions{Quiet: true}` to
+`writeActionResult`. It does not suppress returned errors.
+
+Quiet mode is intentionally not accepted by inspection commands because
+inspection stdout is the command result.
+
+## Summary Ownership
+
+CLI-safe summary structs live in `internal/cli/result.go`.
+
+- `newGenerateSummary` converts `*app.ReportResult` plus an optional error into
+  the generate JSON contract.
+- `newBatchSummary` converts `*app.BatchResult` into the run JSON contract and
+  derives the top-level run status.
+
+Summary types must not expose full app internals, module contents, data package
+contents, raw generated text, Scriptorium result bodies, or full distributor
+payloads.
+
+## Helper Path
+
+New action commands should:
+
+1. parse command-specific flags into CLI option structs;
+2. call the app-layer use case;
+3. convert app results into a CLI summary type;
+4. write through `writeActionResult`;
+5. use a status writer only for routine stderr status lines.
+
+New inspection commands should call the app inspection use case and write the
+returned data through `writeJSON`.

docs/internal/collect.md

@@ -0,0 +1,58 @@
+# Collection Internals
+
+This document describes the app-facing upstream collection boundary in
+`internal/collect`.
+
+## Purpose
+
+`internal/collect` is the canonical package used by app workflows to collect
+upstream Weather API data. It constructs the Weather API adapter, fetches a
+normalized bundle, and returns that bundle without applying report selection or
+batch policy.
+
+## Contract
+
+Inputs:
+
+- `collect.Request`, containing the effective `config.Config`
+- `context.Context` for cancellation
+
+Output:
+
+- `collect.Result`, containing `*weatherdata.Bundle`
+
+`Run` returns an actionable error when Weather API adapter construction or
+bundle fetch fails. The package does not derive `facts.CollectedFacts`, build
+modules, resolve report periods, select reports, write state, invoke
+Scriptorium, or notify distributor.
+
+## App Usage
+
+`internal/app` owns a narrow `Collector` interface for orchestration tests. The
+default implementation calls `collect.Run`.
+
+Single-report generation collects once, resolves the requested report, and
+passes the explicit collection into report generation. Batch generation
+collects once before planning and passes the same collection into each planned
+report. If collection returns no bundle, app orchestration returns an error
+before report generation.
+
+## Boundaries
+
+Weather API HTTP details stay in `internal/adapters/weatherapi`. The collection
+package returns normalized `weatherdata` only. It must not know about report
+IDs, prompt IDs, batch names, Daily eligibility, module composition, Recent
+Changes, state paths, or Scriptorium arguments.
+
+## Tests
+
+Inspect:
+
+- `internal/collect/collect_test.go`
+- `internal/app/app_test.go`
+
+## Invariants
+
+- App-facing Weather API collection goes through `internal/collect`.
+- Collection returns normalized source data, not report facts or prompt input.
+- Report and batch policy belongs outside `internal/collect`.

docs/internal/distributor-adapter.md

@@ -6,10 +6,10 @@ This document describes the distributor upload adapter in
 ## Purpose
 
 The adapter submits generated weatherreporter Markdown reports to a configured
-distributor HTTP upload endpoint. It isolates distributor package types,
-token-env lookup, upload client construction, source-bundle file mapping,
-timeout handling, status polling, and upload error wrapping from app
-orchestration.
+distributor HTTP upload endpoint. It supports one or more file mappings per
+upload request. It isolates distributor package types, token-env lookup, upload
+client construction, source-bundle file mapping, timeout handling, status
+polling, and upload error wrapping from app orchestration.
 
 ## Inputs And Outputs
 
@@ -21,7 +21,7 @@ Inputs:
 - pipeline ID
 - bundle ID
 - idempotency key
-- source Markdown report path and bundle-relative path mappings
+- source Markdown report paths and bundle-relative path mappings
 - bundle created timestamp
 - context for cancellation
 
@@ -40,8 +40,9 @@ Outputs:
 
 The app layer passes weatherreporter-owned request values to the adapter. The
 adapter does not choose report types, render templates, select output copies,
-configure destinations, wait for downstream publication, transform Markdown, or
-persist notification state.
+decide whether an upload represents one report or a batch, configure
+destinations, wait for downstream publication, transform Markdown, or persist
+notification state.
 
 Full upstream distributor package and HTTP contract details stay under
 `docs/integrations/distributor/`.
@@ -54,13 +55,22 @@ The adapter is built from `notify.distributor` config:
 - `token_env`
 - `timeout`
 
-The app layer renders pipeline ID, bundle ID, idempotency key, and bundle paths
-from:
+The app layer renders single-report pipeline ID, bundle ID, idempotency key,
+and bundle paths from:
 
 - `pipeline_id_template`
 - `bundle_id_template`
 - `idempotency_key_template`
-- `report_path_templates`
+- report-specific path templates
+
+For batch uploads, the app layer renders pipeline ID, bundle ID, and
+idempotency key from `notify.distributor.batch.*`, resolves report-specific
+path templates once per included report, and passes the resulting multi-file
+request to this adapter.
+
+Report-specific path resolution happens entirely in the app layer. Explicit
+`reports.<report>.distributor.path_templates` overrides take precedence over
+report definition defaults.
 
 The token value is read from the environment variable named by `token_env`
 after config loading and `secrets.directory` processing.
@@ -70,9 +80,9 @@ after config loading and `secrets.directory` processing.
 The adapter calls distributor `UploadFiles` with one or more file mappings:
 
 - pipeline ID: the rendered distributor workflow selector
-- source path: the managed Markdown report path selected by app orchestration
-- bundle paths: rendered bundle-relative report paths
-- created: the report generation timestamp
+- source paths: managed Markdown report paths selected by app orchestration
+- bundle paths: rendered bundle-relative report paths for each source
+- created: the report or batch generation timestamp
 
 The adapter creates a distributor upload client with the configured endpoint,
 bearer token, and timeout-backed HTTP client. It also wraps the upload context
@@ -115,7 +125,8 @@ distributor service.
 ## Invariants
 
 - Distributor package types do not leak outside the adapter.
-- Only the managed Markdown report is uploaded.
+- Only managed Markdown report paths selected by app orchestration are
+  uploaded.
 - The adapter never scans the workspace.
 - Token values are not included in errors, CLI output, metadata, docs, or
   examples.

docs/internal/generatedtext.md

@@ -7,41 +7,36 @@ This document describes structured generated-text handling in
 
 `internal/generatedtext` validates structured text returned for
 generated-text-template reports and builds curated render contexts for
-templates. The implemented contracts are Tomorrow Report and Hourly Report.
+templates. It also owns the generated-text catalog that connects report
+definitions to validators, render-context builders, schema assets, and template
+assets.
 
 ## Inputs And Outputs
 
 Inputs:
 
-- raw GeneratedText JSON for Tomorrow Report or Hourly Report
+- raw GeneratedText JSON for Daily, Today, Tomorrow Report, or Hourly Report
 - report metadata from `internal/briefing`
 - a module snapshot from `internal/module`
 - validated generated text
 
 Outputs:
 
+- typed `Daily` generated text
+- typed `Today` generated text
 - typed `Tomorrow` generated text
 - typed `Hourly` generated text
 - normalized stable JSON for validated generated text
+- typed `DailyRenderContext` values for `internal/reporttemplate`
+- typed `TodayRenderContext` values for `internal/reporttemplate`
 - typed `TomorrowRenderContext` values for `internal/reporttemplate`
 - typed `HourlyRenderContext` values for `internal/reporttemplate`
+- generated-text catalog handlers for report definitions that use
+  `generated_text_template`
 
-The hourly generated text JSON accepts:
+## JSON Contracts
 
-```json
-{
-  "summary": "string",
-  "forecast_discussion": "string",
-  "precipitation_timing": "string",
-  "confidence": "string"
-}
-```
-
-`summary` and `forecast_discussion` are required after trimming whitespace.
-`precipitation_timing` and `confidence` are optional and omitted from normalized
-JSON when blank.
-
-The Tomorrow generated text JSON accepts:
+Daily, Today, and Tomorrow use the same day-style generated-text JSON shape:
 
 ```json
 {
@@ -52,18 +47,70 @@ The Tomorrow generated text JSON accepts:
 }
 ```
 
-`summary` is required after trimming whitespace. `forecast_discussion` must
-contain at least one nonblank paragraph after trimming blank items.
-`precipitation_timing` and `confidence` are optional and omitted from normalized
-JSON when blank.
+The day-style contract requires `summary` after trimming whitespace.
+`forecast_discussion` must contain at least one nonblank paragraph after
+trimming blank items. `precipitation_timing` and `confidence` are optional and
+omitted from normalized JSON when blank. Unknown fields are rejected.
+
+The report-specific Go API is:
+
+| Report | Type | Validator | Schema ID | Template ID | Prompt ID |
+| --- | --- | --- | --- | --- | --- |
+| Daily Report | `Daily` | `ValidateDaily` | `daily` | `daily` | `weather.daily_generated_text` |
+| Today Report | `Today` | `ValidateToday` | `today` | `today` | `weather.today_generated_text` |
+| Tomorrow Report | `Tomorrow` | `ValidateTomorrow` | `tomorrow` | `tomorrow` | `weather.tomorrow_generated_text` |
+
+Hourly generated text uses the same top-level field names, but
+`forecast_discussion` is a single string:
+
+```json
+{
+  "summary": "string",
+  "forecast_discussion": "string",
+  "precipitation_timing": "string",
+  "confidence": "string"
+}
+```
+
+Hourly `summary` and `forecast_discussion` are required after trimming
+whitespace. `precipitation_timing` and `confidence` are optional and omitted
+from normalized JSON when blank. Unknown fields are rejected. The Hourly catalog
+entry uses type `Hourly`, validator `ValidateHourly`, schema ID `hourly`,
+template ID `hourly`, and prompt ID `weather.hourly_generated_text`.
+
+## Render Contexts
+
+Daily, Today, Tomorrow, and Hourly render contexts all include:
+
+- display metadata derived from report metadata;
+- validated generated text;
+- typed module outputs decoded from the module snapshot;
+- collected facts;
+- derived facts.
+
+Daily, Today, and Tomorrow share common civil-day render-context fields such as
+forecast date labels, valid period, generated-at labels, current conditions,
+hourly forecast, precipitation timing, alert digest, SPC outlooks, AFD, SPC
+discussion, weather story, daily summary, and ordered daypart summaries.
+
+Each civil-day report keeps its report-specific planning module:
+
+- Daily exposes `DailyPlanning`.
+- Today exposes `TodayPlanning`.
+- Tomorrow exposes `TomorrowPlanning`.
+
+Today's ordered daypart context omits unavailable or elapsed dayparts according
+to Today report rules. Daily and Tomorrow use fallback daypart behavior.
 
 ## Boundaries
 
 - This package owns typed generated-text validation and render-context shaping.
+- It owns generated-text catalog lookup for schema/template combinations.
 - It uses typed module snapshot decoding through `module.StanzaValue`.
 - It does not invoke Scriptorium, write state artifacts, choose report
-  definitions, compare snapshots, or render templates directly in production
-  workflows.
+  definitions, compare snapshots, or own embedded template/schema files.
+- It renders through `internal/reporttemplate`; embedded asset lookup remains
+  in `internal/reporttemplate`.
 - It does not use a Go JSON Schema dependency; schema enforcement in Go is
   limited to typed JSON decoding, unknown-field rejection, and required-field
   checks.
@@ -73,22 +120,30 @@ JSON when blank.
 - Malformed generated-text JSON fails with decode context.
 - Unknown generated-text JSON fields fail during decoding.
 - Empty required fields fail after trimming whitespace.
-- Tomorrow forecast discussion fails when no nonblank paragraphs remain.
+- Daily, Today, and Tomorrow forecast discussion fails when no nonblank
+  paragraphs remain.
 - Missing optional render-context stanzas become nil module pointers.
 - Invalid render metadata, including missing timezone, missing generated time,
   or invalid valid period, fails before template rendering.
+- Unsupported generated-text schema IDs, template IDs, or schema/template
+  combinations fail during catalog lookup with report ID context.
 
 ## Tests
 
 Inspect:
 
 - `internal/generatedtext/hourly_test.go`
+- `internal/generatedtext/daily_test.go`
+- `internal/generatedtext/today_test.go`
 - `internal/generatedtext/tomorrow_test.go`
+- `internal/generatedtext/catalog_test.go`
 - `internal/generatedtext/render_context_test.go`
 
 ## Invariants
 
 - Render contexts are curated structs, not raw prompt-input packages.
 - Required generated text is normalized before downstream artifact storage.
+- Generated-text-template reports must have one catalog entry matching their
+  report definition schema and template IDs.
 - Missing optional weather narrative stanzas produce empty or fallback render
   context fields rather than forcing raw module data into templates.

docs/internal/module.md

@@ -5,9 +5,9 @@ This document describes the module contract in `internal/module`.
 ## Purpose
 
 `internal/module` defines the shared identifiers and data envelopes used for
-prompt-facing modules. Report definitions use module IDs for composition,
-module builders produce outputs with stanza names, prompt input packages consume
-snapshots, and Recent Changes compares snapshot stanzas.
+report modules. Report definitions use module IDs for composition, module
+builders produce rich outputs with stanza names, prompt input packages consume
+runtime prompt export values, and Recent Changes compares snapshot stanzas.
 
 ## Inputs And Outputs
 
@@ -23,8 +23,38 @@ Outputs:
 - typed option structs for registered modules
 - `module.Snapshot` with schema version `weatherreporter.modules.v1`
 - ordered snapshot outputs with module ID, stanza name, and typed value
+- runtime-only prompt export values on module outputs
+- `module.Output.DataPackageValue`, which selects the prompt export value and
+  falls back to the rich value for hand-built or loaded snapshots
 - typed stanza lookup through `module.StanzaValue`
 
+## Rich Values And Prompt Exports
+
+Each `module.Output` has two value surfaces:
+
+- `Value`: the rich module value used by templates, module snapshots,
+  inspection, Recent Changes, and render contexts.
+- `PromptValue`: the runtime-only prompt export used when building Scriptorium
+  data packages.
+
+`PromptValue` is deliberately excluded from module snapshot JSON. Persisted
+module snapshots keep only the rich `value` field so inspection and
+render-context reconstruction keep the full deterministic template surface.
+
+The `internal/briefing` module registry attaches prompt export values when it
+builds module outputs. Modules without a custom exporter use default
+pass-through behavior, so their prompt value is the same as their rich value.
+Modules with custom prompt export policy own typed prompt export structs near
+the module builder. Custom prompt exports are:
+
+- `current_conditions`
+- `hourly_forecast`
+- `derived_daypart_summaries`
+
+Custom exporters remove template-only helpers or confusing duplicates from the
+data package without shrinking the rich module structs used by templates.
+Exporter failures include module ID and stanza context.
+
 ## Registered Module IDs
 
 The registry recognizes these IDs:
@@ -42,11 +72,58 @@ The registry recognizes these IDs:
 - `spc_convective_discussion`
 - `weather_story`
 - `outdoor_windows`
+- `today_planning`
 - `tomorrow_planning`
+- `daily_planning`
 
 Every registered module has a builder. Report composition entries that refer to
 unknown or unimplemented module IDs fail validation instead of being skipped.
 
+## Daily Composition
+
+The default Daily Report module order is:
+
+1. `metadata`
+2. `current_conditions`
+3. `narrative_forecast`
+4. `derived_daily_summary`
+5. `derived_daypart_summaries`
+6. `precip_timing`
+7. `alert_digest`
+8. `spc_convective_outlooks`
+9. `area_forecast_discussion`
+10. `spc_convective_discussion`
+11. `weather_story`
+12. `outdoor_windows`
+13. `daily_planning`
+14. `hourly_forecast`
+
+The embedded Daily template uses selected deterministic fields from these
+module outputs after GeneratedText validation. Its `area_forecast_discussion`
+item is configured to include only `long_term`.
+
+## Today Composition
+
+The default Today Report module order is:
+
+1. `metadata`
+2. `current_conditions`
+3. `narrative_forecast`
+4. `derived_daily_summary`
+5. `derived_daypart_summaries`
+6. `precip_timing`
+7. `alert_digest`
+8. `spc_convective_outlooks`
+9. `area_forecast_discussion`
+10. `spc_convective_discussion`
+11. `weather_story`
+12. `outdoor_windows`
+13. `hourly_forecast`
+14. `today_planning`
+
+The embedded Today template uses selected deterministic fields from these
+module outputs after GeneratedText validation.
+
 ## Tomorrow Composition
 
 The default Tomorrow Report module order is:
@@ -69,6 +146,39 @@ The default Tomorrow Report module order is:
 The embedded Tomorrow template uses selected deterministic fields from these
 module outputs after GeneratedText validation.
 
+## Daily Planning
+
+`daily_planning` emits dated daily planning facts for the `daily` report ID.
+Its output stanza is also named `daily_planning`. The module is supported only
+by that report ID and depends on daily summaries for the selected local civil
+day. The default Daily Report composition includes it.
+
+The output uses this shape:
+
+- `morning_readiness`
+- `commute_school_workday_concerns`
+- `overnight_change_watch`
+
+The type is `briefing.DailyPlanningModule`; it is independent from
+`briefing.TomorrowPlanningModule`.
+
+## Today Planning
+
+`today_planning` emits current-day planning facts for Today Report. Its output
+stanza is also named `today_planning`. The module is supported only by Today
+Report and depends on daily and daypart summaries for the current local civil
+day.
+
+The output uses this shape:
+
+- `morning_readiness`
+- `commute_school_workday_concerns`
+- `outdoor_planning`
+- `late_day_change_watch`
+
+The type is `briefing.TodayPlanningModule`; it is independent from
+`briefing.TomorrowPlanningModule`.
+
 ## Hourly Composition
 
 The default Hourly Report module order is:
@@ -107,7 +217,7 @@ validation.
 
 ## SPC Convective Module Outputs
 
-`spc_convective_outlooks` emits a prompt-facing risk-product stanza with:
+`spc_convective_outlooks` emits a risk-product stanza with:
 
 - `checked`
 - `as_of`
@@ -116,12 +226,19 @@ validation.
 - `location_name`
 - `outlook_count`
 - `outlooks`
+- `risk_digest`
 
 Each outlook entry may include `day`, `outlook_type`, `label`, `label_text`,
 `period_begins`, `period_ends`, `issued_at`, `contains_location`, and
 `image_url`. It omits GeoJSON geometry, source URL, expiration time, and
 severity rank.
 
+The optional `risk_digest` list is a curated report-rendering subset of
+categorical outlooks that overlap the report period, contain the configured
+location, and meet the minimum severity threshold. Entries include `label_text`,
+`risk_label`, `period_begins`, and `period_ends`; they do not expose severity
+rank.
+
 `spc_convective_discussion` emits a narrative stanza only when a retained
 report-period categorical outlook has severity rank `3` or higher and matching
 discussion text is available. Its output includes `included_because` and
@@ -134,7 +251,7 @@ meet the severity threshold.
 
 - This package owns module identifiers, config item envelopes, output
   envelopes, snapshot validation, and typed stanza lookup.
-- It does not define report IDs, execute builders, fetch weather data, derive
+- It does not define report IDs, execute builders, collect weather data, derive
   forecast facts, write state, or invoke Scriptorium.
 
 ## State Or Manifest Behavior
@@ -142,7 +259,8 @@ meet the severity threshold.
 `module.Snapshot` values are persisted by `internal/state` as JSON. Snapshot
 validation rejects missing schema version, missing module IDs, missing stanza
 names, duplicate module outputs, and duplicate stanza names while preserving
-output order.
+output order. Snapshot JSON contains rich module values only; runtime prompt
+export values are not persisted.
 
 ## Failure Behavior
 
@@ -163,5 +281,8 @@ Inspect:
 
 - `internal/module` does not import `internal/report`.
 - Module IDs are stable strings.
-- Each emitted module output has exactly one stanza name and one typed value.
+- Each emitted module output has exactly one stanza name and one rich typed
+  value.
+- Built module outputs have a data-package value, either from a custom prompt
+  exporter or from default pass-through behavior.
 - Snapshot output order is caller-owned and preserved.

docs/internal/prompt-input.md

@@ -5,13 +5,15 @@ This document describes YAML prompt data package construction in
 
 ## Purpose
 
-`internal/promptinput` converts report metadata, an ordered module snapshot,
-Recent Changes, and source warnings into the `data_package` file passed to
+`internal/promptinput` converts report metadata, ordered module outputs, Recent
+Changes, and source warnings into the `data_package` file passed to
 Scriptorium.
 
 The persisted data package is YAML with schema version
-`weatherreporter.data_package.v2`. It is separate from the JSON module snapshot
-used for inspection and comparison.
+`weatherreporter.data_package.v3`. It is separate from the JSON module snapshot
+used for inspection and comparison. Data packages serialize each module
+output's prompt export value, not necessarily the full rich module value saved
+in the module snapshot.
 
 ## Inputs And Outputs
 
@@ -32,7 +34,7 @@ Outputs:
 The YAML shape includes:
 
 ```yaml
-schema_version: weatherreporter.data_package.v2
+schema_version: weatherreporter.data_package.v3
 run_id: <run_id>
 report:
   id: <report_id>
@@ -68,9 +70,35 @@ Prompt-facing module intervals use local `period_begins` and `period_ends`
 labels; canonical report metadata and source timestamps remain structured
 timestamps where applicable.
 
-Tomorrow Report and Hourly Report module snapshots use the same package schema
-and categories when converted into prompt input. The default hourly module list
-places
+## Module Export Boundary
+
+Data packages are curated prompt inputs. They are not full template render
+contexts and should not be treated as a dump of every field available to Go
+templates.
+
+When module outputs are built by `internal/briefing`, the registry attaches a
+runtime prompt export value. `internal/promptinput` serializes
+`output.DataPackageValue()` for each stanza. That helper prefers the runtime
+prompt export and falls back to the rich `Value` when no prompt export is set,
+which keeps loaded snapshots and hand-built tests usable.
+
+Modules without custom export policy use pass-through behavior. Modules with
+custom exports currently include:
+
+- `current_conditions`: omits lower-case condition text and duplicate
+  wind-direction text.
+- `hourly_forecast`: omits hour labels, lower-case description text, and the
+  template precipitation-mention helper while keeping forecast facts.
+- `derived_daypart_summaries`: omits deterministic sentence-construction
+  helpers while keeping daypart period, condition, temperature trend,
+  precipitation, wind, notable-condition, hazard, and alert-relevance facts.
+
+The rich module snapshot and generated-template render context still contain
+the helper fields used by deterministic Markdown templates.
+
+Daily Report, Today Report, Tomorrow Report, and Hourly Report module snapshots
+use the same package schema and categories when converted into prompt input.
+The default hourly module list places
 `precip_timing` under `derived_summaries`, alert and SPC outlooks under
 `applicable_risk_products`, AFD/SPC discussion/weather story under
 `narrative_products`, and current/hourly data under `raw_data`. It does not
@@ -78,9 +106,11 @@ include civil-day summary stanzas. Generated-text and render context artifacts
 are produced later in app orchestration and are not part of the YAML data
 package.
 
-The default Tomorrow module list includes civil-day summary stanzas,
-`tomorrow_planning`, and `hourly_forecast` in the data package before
-structured GeneratedText is requested from Scriptorium.
+The default Daily, Today, and Tomorrow module lists include civil-day summary
+stanzas, planning stanzas, and `hourly_forecast` in the data package before
+structured GeneratedText is requested from Scriptorium. Daily uses
+`daily_planning`, Today uses `today_planning`, and Tomorrow uses
+`tomorrow_planning`.
 
 Current categories are:
 
@@ -98,9 +128,9 @@ Current categories are:
 
 - This package owns prompt package schema, YAML marshaling, YAML loading, and
   validation.
-- It does not fetch weather data, derive forecast summaries, execute modules,
-  find prior snapshots, compare changes, choose artifact paths, or invoke
-  Scriptorium.
+- It does not collect weather data, derive forecast summaries, execute modules,
+  choose module prompt export shapes, find prior snapshots, compare changes,
+  choose artifact paths, or invoke Scriptorium.
 
 ## Config Fields Used
 
@@ -140,5 +170,8 @@ Inspect:
 - Scriptorium receives structured YAML through `--input data_package=<path>`.
 - Module stanza order is deterministic within each prompt-facing category.
 - Every non-metadata module stanza has exactly one prompt-input category.
+- Data-package stanzas use curated module prompt exports when present and rich
+  values only as pass-through or fallback values.
+- Data packages are narrower than generated-template render contexts.
 - Recent Changes are provided by `internal/changes`; this package does not
   infer changes from rendered report text.

docs/internal/report-registry.md

@@ -1,14 +1,15 @@
 # Report Registry Internals
 
-This document describes report identity, valid-period resolution, batch
-membership, output naming, artifact grouping, and comparison declarations in
+This document describes report identity, valid-period resolution, output
+naming, artifact grouping, batch command names, and comparison declarations in
 `internal/report`.
 
 ## Purpose
 
-`internal/report` is the canonical source for report definitions. App, state,
-module building, and CLI wiring consume resolved definitions instead of owning
-report identity policy themselves.
+`internal/report` is the canonical source for report definitions, public
+command names, config-key aliases, and batch command names. App, config, state,
+module building, and CLI wiring consume report-owned helpers and resolved
+definitions instead of owning report identity policy themselves.
 
 ## Definition Fields
 
@@ -23,20 +24,30 @@ Each report definition declares:
 - batch output copy filename
 - generated-report eligibility
 - prior-report compatibility list
-- morning or evening batch membership
 - default ordered module composition
 
+Report-owned helpers map public command names and config keys to report IDs.
+The generate command names are `daily`, `today`, `tomorrow`, `hourly`,
+`three-day`, `weekend`, and `storm`. Config keys also accept selected
+underscore and descriptive aliases such as `three_day_outlook`,
+`weekend_outlook`, and `storm_report`.
+
+`daily` resolves to the dated Daily Report ID `daily`. `today` resolves to the
+independent Today report ID `today`. `reports.today` is not an alias for
+`reports.daily`, and retired report keys are not supported.
+
 Markdown report definitions use the `scriptorium_markdown` generation mode.
-Their template and structured-text schema identifiers are empty. Tomorrow
-Report and Hourly Report declare `generated_text_template`; the app uses their
-template and schema identifiers to validate generated text and render embedded
-Markdown templates.
+Their template and structured-text schema identifiers are empty. Daily Report,
+Today Report, Tomorrow Report, and Hourly Report declare
+`generated_text_template`; the app uses their template and schema identifiers
+to validate generated text and render embedded Markdown templates.
 
 ## Reports
 
 | Report | ID | Prompt | Generation mode | Artifact group | Batch copy | Prior compatibility |
 | --- | --- | --- | --- | --- | --- | --- |
-| Daily Today | `daily_today` | `weather.daily_report` | `scriptorium_markdown` | `daily` | `daily.md` | Daily Today |
+| Daily Report | `daily` | `weather.daily_generated_text` | `generated_text_template` | `daily` | `daily.md` | Daily Report |
+| Today Report | `today` | `weather.today_generated_text` | `generated_text_template` | `today` | `today.md` | Today Report |
 | Tomorrow Report | `tomorrow` | `weather.tomorrow_generated_text` | `generated_text_template` | `tomorrow` | `tomorrow.md` | Tomorrow Report |
 | Hourly Report | `hourly` | `weather.hourly_generated_text` | `generated_text_template` | `hourly` | `hourly.md` | Hourly Report |
 | 3-Day Outlook | `three_day` | `weather.three_day_outlook` | `scriptorium_markdown` | `three-day` | `three-day.md` | 3-Day Outlook |
@@ -47,7 +58,9 @@ All report definitions are eligible for generation.
 
 ## Valid Periods
 
-- Daily Today covers the selected local civil day, or the current local civil
+- Daily Report covers the selected local civil day and requires an explicit
+  date.
+- Today Report covers the selected local civil day, or the current local civil
   day when no date override is supplied.
 - Tomorrow Report covers the next local civil day from generation time.
 - Hourly Report covers the half-open six-hour period from generation time in
@@ -55,8 +68,7 @@ All report definitions are eligible for generation.
   not a configuration field.
 - 3-Day Outlook covers the interval from generation time through local midnight
   three days later.
-- Weekend Outlook covers the upcoming weekend window and is not scheduled for
-  Sunday morning batch resolution.
+- Weekend Outlook covers the upcoming weekend window.
 - Storm Report covers an explicit event window supplied by the caller.
 
 Storm event windows can be parsed from local `YYYY-MM-DDTHH:MM` timestamps in
@@ -65,25 +77,32 @@ must be after start time.
 
 ## Boundaries
 
-`internal/report` defines report metadata and time coverage. It does not fetch
-weather data, build module values, compare snapshot contents, write state,
+`internal/report` defines report metadata, public report names, batch command
+names, output naming, and time coverage. It does not collect weather data, plan
+batch membership, build module values, compare snapshot contents, write state,
 parse CLI flags, or invoke Scriptorium.
 
-The CLI owns public command names. The app maps those command names to report
-IDs, then uses the registry for report policy.
+The CLI parses flags and command structure, then uses report-owned helpers for
+report and batch command names. Config loading uses report-owned helpers for
+report override keys.
 
 ## Config Fields Used
 
 The app supplies `weather_api.timezone` as a loaded `time.Location`. Batch
 output path copying uses batch output names from report definitions. Report
-module overrides can use short keys such as `tomorrow` and `hourly`, or
-canonical report IDs such as `daily_today`.
+module overrides can use short keys such as `daily`, `today`, `tomorrow`, and
+`hourly`, or descriptive names such as `three_day_outlook`.
 
-## Batch Membership
+## Batch Commands
 
-Morning batches include Daily Today, 3-Day Outlook, and Weekend Outlook except
-on Sunday. Evening batches include Tomorrow Report. Hourly Report is not part
-of a scheduled batch.
+`internal/report` owns the public batch command names `morning` and `evening`
+and validates them through `BatchForCommandName`. Data-dependent batch
+membership is owned by `internal/app`, because it depends on collected hourly
+forecast coverage.
+
+Report definitions still declare default batch output copy filenames. App
+batch planning uses those filenames for fixed report entries and supplies
+date-qualified names for dynamic Daily entries.
 
 ## State And App Usage
 
@@ -111,6 +130,8 @@ Inspect:
 ## Invariants
 
 - Report selection goes through the registry.
+- Public command names, config-key aliases, and batch command names are owned
+  by `internal/report`.
 - Direct Markdown reports have empty template and generated-text schema IDs.
 - Generated-text-template reports declare prompt, template, and schema IDs in
   their report definition.
@@ -118,3 +139,5 @@ Inspect:
 - Artifact grouping, batch output filenames, generated-report eligibility,
   default module composition, comparison compatibility, and comparison strategy
   are declared by report definition.
+- App-owned batch planning uses report definitions but does not live in the
+  report registry.

docs/internal/reporttemplate.md

@@ -6,14 +6,19 @@ in `internal/reporttemplate`.
 ## Purpose
 
 `internal/reporttemplate` owns repository-native report templates and companion
-GeneratedText JSON schemas. The implemented template contracts are Tomorrow
-Report and Hourly Report.
+GeneratedText JSON schemas. The implemented template assets are Daily, Today,
+Tomorrow, and Hourly.
 
 The package embeds assets from:
 
 - `internal/reporttemplate/templates/*.md.tmpl`
+- `internal/reporttemplate/templates/partials/*.md.tmpl`
 - `internal/reporttemplate/schemas/*.schema.json`
 
+Generated-text prompt source files live under
+`internal/reporttemplate/prompts/`. They are repository assets for prompt
+registration, not embedded lookup APIs.
+
 ## Inputs And Outputs
 
 Inputs:
@@ -27,24 +32,29 @@ Outputs:
 - GeneratedText schema bytes for prompt/schema configuration
 - rendered Markdown bytes for app orchestration to persist
 
-The implemented template IDs are `tomorrow` and `hourly`. The implemented
-schema IDs are also `tomorrow` and `hourly`, backed by
-`tomorrow.generated_text.schema.json` and `hourly.generated_text.schema.json`.
+The implemented template IDs are `daily`, `today`, `tomorrow`, and `hourly`.
+The implemented schema IDs are also `daily`, `today`, `tomorrow`, and
+`hourly`, backed by matching `*.generated_text.schema.json` files.
+
+Generated-text prompt sources are maintained under
+`internal/reporttemplate/prompts/`, including Daily's
+`daily.generated_text.md` source for prompt ID `weather.daily_generated_text`.
 
 ## Boundaries
 
 This package owns embedded asset lookup, Go template parsing, and Markdown
-template execution. It does not fetch weather data, build module outputs,
+template execution. It does not collect weather data, build module outputs,
 validate GeneratedText, construct render contexts, choose report definitions,
 write artifacts, invoke Scriptorium, or notify distributor.
 
 GeneratedText validation is owned by `internal/generatedtext`. App
-orchestration decides which template and schema IDs apply to a report through
-`internal/report` definitions.
+orchestration uses `internal/generatedtext` catalog lookup to connect
+`internal/report` definition schema/template IDs to the matching validator,
+render-context builder, and embedded assets.
 
 ## Template Contracts
 
-Tomorrow and Hourly rendering use typed render contexts with:
+Daily, Today, Tomorrow, and Hourly rendering use typed render contexts with:
 
 - report metadata labels such as title, location, valid period, and generation
   time
@@ -53,14 +63,26 @@ Tomorrow and Hourly rendering use typed render contexts with:
   conditions, hourly forecast rows, precipitation timing, alerts, SPC outlooks,
   forecast discussion, SPC discussion, and weather story
 
-Tomorrow additionally exposes forecast-date labels, ordered daypart forecast
-rows, daily/daypart summaries, tomorrow planning facts, and a multi-paragraph
-forecast discussion generated-text slot. The ordered daypart slice is built in
-Go so templates do not range over maps.
+Daily, Today, and Tomorrow additionally expose forecast-date labels, ordered
+daypart forecast rows, daily/daypart summaries, planning facts, and a
+multi-paragraph forecast discussion generated-text slot. The ordered daypart
+slice is built in Go so templates do not range over maps.
+
+The Daily template asset uses the same Markdown structure as Tomorrow's
+template and renders from `generatedtext.DailyRenderContext`.
 
 Templates use `text/template` with `missingkey=error`, so missing context fields
 fail rendering instead of producing incomplete Markdown.
 
+Daily and Tomorrow call the shared `daypart_forecast` partial. Today calls
+`today_daypart_forecast` so it can omit elapsed or missing dayparts. Daily,
+Today, Tomorrow, and Hourly call the shared `alert_digest` and
+`precipitation_timing` partials. Partial files are parsed with each top-level
+template at render time and receive the same typed render context as the
+caller. The `alert_digest` partial renders the combined Alerts and Risk
+Products section from relevant NWS alerts and curated SPC outlook digest
+records.
+
 ## Schema Contract
 
 The GeneratedText schemas describe the structured prose Scriptorium is expected
@@ -69,16 +91,18 @@ to write for each generated-text prompt. Hourly requires:
 - `summary`
 - `forecast_discussion`
 
-Tomorrow requires `summary` and a nonempty `forecast_discussion` array. Both
-schemas allow optional `precipitation_timing` and `confidence`, and reject
-additional properties. Weather truth remains in module outputs; GeneratedText
-is limited to prose slots consumed by the template.
+Daily, Today, and Tomorrow require `summary` and a nonempty
+`forecast_discussion` array. All generated-text schemas allow optional
+`precipitation_timing` and `confidence`, and reject additional properties.
+Weather truth remains in module outputs; GeneratedText is limited to prose
+slots consumed by the template.
 
 ## Failure Behavior
 
 - Unknown template IDs return actionable lookup errors.
 - Unknown schema IDs return actionable lookup errors.
 - Template parse errors include the template ID.
+- Partial read or parse errors include the partial path.
 - Template execution errors include the template ID and usually identify the
   missing context field.
 
@@ -94,6 +118,7 @@ Inspect:
 ## Invariants
 
 - Embedded templates and schemas live as separate files, not inline Go strings.
+- Shared Markdown partials live under `templates/partials/`.
 - Report definitions select templates by ID.
 - Templates render from curated render contexts, not raw data packages.
 - GeneratedText schemas describe LLM prose slots, not deterministic weather

docs/internal/scriptorium-adapter.md

@@ -34,7 +34,7 @@ Outputs:
 
 `internal/adapters/scriptorium` owns Scriptorium command construction and
 subprocess execution. It does not choose report types, build prompt input,
-fetch weather data, decide workflow order, or persist workflow metadata.
+collect weather data, decide workflow order, or persist workflow metadata.
 
 The adapter exposes request and result structs for render, Markdown run, and
 structured generated-text run operations. State persistence uses state-owned

docs/internal/state.md

@@ -31,6 +31,7 @@ Outputs:
 - render context JSON path
 - managed Markdown report path
 - metadata JSON path
+- distributor notification debug artifact paths
 - prior comparable snapshot metadata
 - loaded module snapshot, data package, generated text, generated-text run
   result, or render context
@@ -61,20 +62,22 @@ Workspace subdirectories must be relative paths that stay under
 ## Managed Layout
 
 Paths are derived from the resolved report definition's artifact group, the
-valid-period start date for dated artifacts, and the RunID.
+valid-period start date, and the RunID. Filenames put the artifact kind before
+the RunID.
 
 ```text
 <workspace.root>/
-  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.modules.json
-  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.metadata.json
-  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.generated_text.raw.json
-  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.generated_text.run.json
-  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.generated_text.json
-  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.render_context.json
-  data-packages/<artifact_group>/<YYYY-MM-DD>/<run_id>.data_package.yaml
-  preflight/<artifact_group>/<YYYY-MM-DD>/<run_id>.render.json
-  notifications/<artifact_group>/<YYYY-MM-DD>/<run_id>.distributor.json
-  reports/<artifact_group>/<run_id>.md
+  reports/<artifact_group>/<YYYY-MM-DD>/report.<run_id>.md
+  snapshots/<artifact_group>/<YYYY-MM-DD>/modules.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/metadata.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/generated_text_raw.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/generated_text_result.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/generated_text.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/render_context.<run_id>.json
+  data-packages/<artifact_group>/<YYYY-MM-DD>/data_package.<run_id>.yaml
+  preflight/<artifact_group>/<YYYY-MM-DD>/render.<run_id>.json
+  notifications/<artifact_group>/<YYYY-MM-DD>/distributor.<run_id>.json
+  notifications/batches/<batch>/<YYYY-MM-DD>/distributor.<batch_run_id>.json
 ```
 
 Metadata is stored beside module snapshots and links the module snapshot, data
@@ -85,13 +88,19 @@ Scriptorium run result, validated generated text, and render context artifacts.
 Markdown-report metadata omits those generated-text fields. Report listing
 walks metadata files under the snapshots directory.
 
+Batch notification artifacts are stored under the notifications tree rather
+than report metadata because they describe a batch-level upload. The date
+directory is the batch start date in the effective report timezone.
+
 ## Prior Lookup
 
 Prior snapshot lookup reads stored metadata through the shared lookup path and
 selects the latest earlier snapshot whose report ID is compatible with the
 current report definition.
 
-- Daily Today compares with prior Daily Today snapshots for the same valid
+- Daily Report compares with prior Daily Report snapshots for the same valid
+  local date.
+- Today Report compares with prior Today Report snapshots for the same valid
   local date.
 - Tomorrow Report compares with prior Tomorrow Report snapshots for the same
   valid local date.
@@ -116,6 +125,27 @@ atomically when notification is attempted and include rendered distributor
 pipeline ID, bundle ID, idempotency key, bundle paths, upload status, latest
 run status, and redacted errors.
 
+Single-report notification artifacts use schema version
+`weatherreporter.distributor_notification.v1` and record one managed source
+path plus that source's bundle paths. Batch notification artifacts use schema
+version `weatherreporter.batch_distributor_notification.v1` and record:
+
+- `batch`
+- `batchRunId`
+- `attemptedAt`
+- `endpoint`
+- `pipelineId`
+- `bundleId`
+- `idempotencyKey`
+- `bundleCreated`
+- `includedReports`, each with `reportId`, `runId`, `sourcePath`, and
+  `bundlePaths`
+- `status`
+- `upload`
+- `runStatus`
+- `statusError`
+- `error`
+
 Inspection helpers read existing metadata, module snapshot, data package,
 generated text, generated-text run result, and render context files. Missing
 metadata directories return no inspection records or no prior snapshot rather
@@ -143,4 +173,6 @@ Inspect:
 - Metadata links artifacts produced for a run.
 - Generated-text artifacts live under the snapshots tree beside module
   snapshots and metadata.
+- Batch notification artifacts live under `notifications/batches` and are not
+  linked from report metadata.
 - Prior lookup is based on structured metadata, not rendered report text.

docs/operations.md

@@ -10,6 +10,7 @@ Generation commands:
 
 ```text
 weatherreporter generate daily --date 2026-05-29
+weatherreporter generate today
 weatherreporter generate tomorrow
 weatherreporter generate hourly
 weatherreporter generate three-day
@@ -17,23 +18,28 @@ weatherreporter generate weekend
 weatherreporter generate storm --start 2026-05-29T18:00 --end 2026-05-30T06:00
 ```
 
-Generation commands resolve a report period, fetch a Weather API bundle, build
-a JSON module snapshot, build a YAML prompt input data package, run
-`scriptorium render`, and write managed artifacts under the configured
-workspace. Markdown-path reports then run `scriptorium run` directly to the
-managed Markdown report path.
+Generation commands resolve a report period, collect a Weather API bundle,
+build a rich JSON module snapshot, build a curated YAML prompt input data
+package, run `scriptorium render`, and write managed artifacts under the
+configured workspace. Markdown-path reports then run `scriptorium run` directly
+to the managed Markdown report path.
 
-`generate tomorrow` and `generate hourly` use the generated-text-template
-workflow. They run structured `scriptorium run` to raw GeneratedText JSON,
-validate the structured text, save a render context, and render the managed
-Markdown report from embedded templates. `generate hourly` covers the six-hour
-rolling period from generation time in the effective report timezone and is not
-part of scheduled morning or evening batches.
+`generate daily`, `generate today`, `generate tomorrow`, and `generate hourly`
+use the generated-text-template workflow. They run structured `scriptorium run`
+to raw GeneratedText JSON, validate the structured text, save a render context,
+and render the managed Markdown report from embedded templates. `generate
+daily` requires `--date YYYY-MM-DD` for the selected local civil day.
+`generate today` covers the selected or current local civil day. `generate
+hourly` covers the six-hour rolling period from generation time in the
+effective report timezone and is not included in `run morning` or
+`run evening`.
 
 When distributor notification is enabled, weatherreporter uploads the managed
 Markdown report after report rendering succeeds and final metadata is saved.
 `--out PATH` writes an extra Markdown copy for generated reports; it is not used
-as the distributor upload source.
+as the distributor upload source. Generate commands emit a compact JSON summary
+to stdout by default. Use `--quiet` to suppress successful stdout for cron jobs
+or other schedulers that only need nonzero exits and external logs.
 
 Batch commands:
 
@@ -42,16 +48,26 @@ weatherreporter run morning
 weatherreporter run evening
 ```
 
-`run morning` generates Daily Today and the 3-Day Outlook, plus Weekend Outlook
-except on Sunday. `run evening` generates the Tomorrow Report. Batch
-commands print a JSON summary to stdout, write compact per-report status lines
-to stderr, continue independent reports after one report fails, and return
-nonzero when any report failed. When notification is configured, the summary and
-status lines include notification status, accepted distributor run ID, or
-notification error fields for each attempted report. `--out-dir PATH` writes
-extra Markdown copies using report default filenames such as `daily.md`,
-`three-day.md`, `weekend.md`, and `tomorrow.md`; these copies are not used as
-distributor upload sources.
+`run morning` generates Today Report, Tomorrow Report, and a dated Daily Report
+for each later future local civil day with complete hourly forecast coverage.
+`run evening` generates Tomorrow Report and the same eligible future Daily
+reports. Future Daily expansion starts with the day after tomorrow. A Daily
+report is eligible only when the collected hourly forecast contains every
+hourly period for that local civil day; partial days are skipped. Batch commands
+collect weather data once before planning, and a collection failure stops the
+batch before any report is generated.
+
+After planning succeeds, batch commands print a JSON summary to stdout, write
+compact per-report status lines to stderr, continue independent reports after
+one report fails, and return nonzero when any report failed. Batch commands do
+not upload each report independently. When distributor notification and batch
+notification are enabled, weatherreporter uploads one distributor bundle only
+after every planned report succeeds. If any report fails, the batch upload is
+skipped for the whole batch. `--out-dir PATH` writes extra Markdown copies
+using report default filenames such as `today.md` and `tomorrow.md`; dynamic
+Daily copies use `daily-YYYY-MM-DD.md`. These copies are not used as
+distributor upload sources. Use `--quiet` to suppress successful batch summary
+and status output; failures still return nonzero.
 
 ## Filesystem Layout
 
@@ -59,120 +75,45 @@ The default workspace root is `workspace`.
 
 ```text
 workspace/
-  snapshots/
-    daily/
-      YYYY-MM-DD/
-        <run_id>.modules.json
-        <run_id>.metadata.json
-    three-day/
-      YYYY-MM-DD/
-        <run_id>.modules.json
-        <run_id>.metadata.json
-    weekend/
-      YYYY-MM-DD/
-        <run_id>.modules.json
-        <run_id>.metadata.json
-    hourly/
-      YYYY-MM-DD/
-        <run_id>.modules.json
-        <run_id>.metadata.json
-        <run_id>.generated_text.raw.json
-        <run_id>.generated_text.run.json
-        <run_id>.generated_text.json
-        <run_id>.render_context.json
-    tomorrow/
-      YYYY-MM-DD/
-        <run_id>.modules.json
-        <run_id>.metadata.json
-        <run_id>.generated_text.raw.json
-        <run_id>.generated_text.run.json
-        <run_id>.generated_text.json
-        <run_id>.render_context.json
-    storm/
-      YYYY-MM-DD/
-        <run_id>.modules.json
-        <run_id>.metadata.json
-  data-packages/
-    daily/
-      YYYY-MM-DD/
-        <run_id>.data_package.yaml
-    three-day/
-      YYYY-MM-DD/
-        <run_id>.data_package.yaml
-    weekend/
-      YYYY-MM-DD/
-        <run_id>.data_package.yaml
-    hourly/
-      YYYY-MM-DD/
-        <run_id>.data_package.yaml
-    tomorrow/
-      YYYY-MM-DD/
-        <run_id>.data_package.yaml
-    storm/
-      YYYY-MM-DD/
-        <run_id>.data_package.yaml
-  preflight/
-    daily/
-      YYYY-MM-DD/
-        <run_id>.render.json
-    three-day/
-      YYYY-MM-DD/
-        <run_id>.render.json
-    weekend/
-      YYYY-MM-DD/
-        <run_id>.render.json
-    hourly/
-      YYYY-MM-DD/
-        <run_id>.render.json
-    tomorrow/
-      YYYY-MM-DD/
-        <run_id>.render.json
-    storm/
-      YYYY-MM-DD/
-        <run_id>.render.json
-  notifications/
-    daily/
-      YYYY-MM-DD/
-        <run_id>.distributor.json
-    three-day/
-      YYYY-MM-DD/
-        <run_id>.distributor.json
-    weekend/
-      YYYY-MM-DD/
-        <run_id>.distributor.json
-    hourly/
-      YYYY-MM-DD/
-        <run_id>.distributor.json
-    tomorrow/
-      YYYY-MM-DD/
-        <run_id>.distributor.json
-    storm/
-      YYYY-MM-DD/
-        <run_id>.distributor.json
-  reports/
-    daily/
-      <run_id>.md
-    three-day/
-      <run_id>.md
-    weekend/
-      <run_id>.md
-    hourly/
-      <run_id>.md
-    tomorrow/
-      <run_id>.md
-    storm/
-      <run_id>.md
+  reports/<artifact_group>/<YYYY-MM-DD>/report.<run_id>.md
+
+  snapshots/<artifact_group>/<YYYY-MM-DD>/modules.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/metadata.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/generated_text_raw.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/generated_text_result.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/generated_text.<run_id>.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/render_context.<run_id>.json
+
+  data-packages/<artifact_group>/<YYYY-MM-DD>/data_package.<run_id>.yaml
+  preflight/<artifact_group>/<YYYY-MM-DD>/render.<run_id>.json
+
+  notifications/<artifact_group>/<YYYY-MM-DD>/distributor.<run_id>.json
+  notifications/batches/<batch>/<YYYY-MM-DD>/distributor.<batch_run_id>.json
 ```
 
-Managed artifact filenames use the RunID, so repeated runs for the same valid
-period do not overwrite each other.
+Managed artifact filenames use the artifact kind and RunID, so repeated runs
+for the same valid period do not overwrite each other. The date directory is
+the valid-period start date in the effective report timezone. Generated-text
+artifacts are written only for Daily, Today, Tomorrow, and Hourly reports.
 
 ## RunID And Metadata
 
-RunIDs are based on generation time plus report ID:
+RunIDs are based on generation time plus report ID. Reports that can be
+generated more than once in a single command may append a report-specific
+disambiguator. Daily appends the local valid date so multiple dynamic Daily
+reports in one batch have distinct managed artifacts:
 
 ```text
-20260529T100000.123456789Z_daily_today
+20260529T100000.123456789Z_daily_2026-05-31
+20260529T100000.123456789Z_today
+```
+
+Batch notification RunIDs use the batch start timestamp plus the batch command
+name:
+
+```text
+20260529T100000.123456789Z_morning
+20260529T220000.123456789Z_evening
 ```
 
 Each generated report writes metadata that links:
@@ -188,19 +129,32 @@ Each generated report writes metadata that links:
   generated-text-template reports
 - distributor notification debug artifact path, when notification is attempted
 
-Batch summaries include report status, error text when applicable, notification
-outcome when attempted, valid period, and known artifact paths for each
-attempted report. Notification fields are `notificationStatus`,
-`notificationRunId`, and `notificationError`.
+Batch summaries include report status, error text when applicable, valid
+period, and known artifact paths for each attempted report. Single-report
+notification fields on report items are empty for batch commands. When a batch
+notification is attempted, skipped, or fails, the summary includes one
+top-level `notification` object with fields such as `status`, `reason`,
+`runId`, `pipelineId`, `bundleId`, `idempotencyKey`, `path`,
+`includedReports`, and `error`.
 
 ## Distributor Notification
 
 Distributor notification is configured with `notify.distributor` and is
-disabled by default. When enabled, weatherreporter uploads the managed Markdown
-report path recorded in the report result and metadata. That single source file
-can be mapped to one or more configured bundle paths. By default, it is mapped
-to one dated report path. Extra copies written by `--out` or `--out-dir` are
-operator conveniences only.
+disabled by default. For `generate <report>`, weatherreporter uploads the
+managed Markdown report path recorded in the report result and metadata. That
+single source file is mapped to report-specific bundle paths. Extra copies
+written by `--out` or `--out-dir` are operator conveniences only.
+
+For `run morning` and `run evening`, per-report notification is suppressed. If
+`notify.distributor.enabled` and `notify.distributor.batch.enabled` are both
+true, the batch uploads once after all reports finish successfully. The upload
+contains one file mapping set per included report. Each mapping uses the
+managed Markdown report as the source and report-specific path templates for
+that report. All rendered bundle paths across the batch must be unique. If any
+report fails, weatherreporter records a top-level
+notification status of `skipped` with reason `one or more reports failed` and
+does not call distributor. If batch notification is disabled, run commands do
+not fall back to per-report uploads.
 
 The rendered pipeline ID selects the configured distributor `http_upload`
 workflow. The default bundle ID is a stable logical source identity derived from
@@ -210,27 +164,40 @@ producer name, location ID, and report ID:
 weatherreporter.{location_id}.{report_id}
 ```
 
-The default idempotency key appends RunID to the rendered bundle ID so each
-report generation has a distinct retry identity. The default bundle path uses
-the valid-period start date, artifact group, and RunID. Distributor owns
-destination merge, retention, and derived snapshot behavior such as `latest`.
+The default single-report idempotency key appends RunID to the rendered bundle
+ID so each report generation has a distinct retry identity. The default bundle
+path uses the valid-period start date, artifact group, and RunID. Batch bundle
+IDs default to `weatherreporter.{location_id}.{batch}`, and batch idempotency
+keys default to `{bundle_id}.{batch_run_id}`. Distributor owns destination
+merge, retention, and derived snapshot behavior such as `latest`. For Daily,
+the default report ID and artifact group values are both `daily`, and the
+default output filename value is `daily.md`. For Today, the default report ID
+and artifact group values are both `today`, and the batch output filename value
+is `today.md`.
 
-Notification happens after final metadata save for generated reports. Weather
-API, module snapshot, data-package, render preflight, Scriptorium run,
-generated-text validation, template rendering, and metadata-save failures do
-not trigger notification. A notification failure fails that report.
-In a batch, other reports continue, the failed report includes notification
-fields in the JSON summary, and the batch returns nonzero.
+Single-report notification happens after final metadata save for generated
+reports. Batch notification happens after all planned reports have finished and
+only when all report generations succeeded. Collection, module snapshot,
+data-package, render preflight, Scriptorium run, generated-text validation,
+template rendering, and metadata-save failures do not trigger notification. A
+single-report notification failure fails that report. A batch notification
+failure makes the batch return nonzero and increments the aggregate failure
+count, but individual report items remain succeeded.
 
-Each notification attempt writes a debug artifact under `notifications/`. The
-artifact records the rendered pipeline ID, bundle ID, idempotency key, managed
-source path, bundle-relative paths, bundle created timestamp, accepted upload
-response, and the latest distributor run status response when available.
-Weatherreporter polls status until distributor reports `succeeded` or `failed`,
-or until the configured notification timeout expires. The run status includes
-the distributor status, error text, and raw run report JSON, which can show
-actions such as `replace_older`, `skip_same`, `skip_destination_newer`, or
-`failed`. Token values are not written.
+Each notification attempt writes a debug artifact under `notifications/`.
+Single-report artifacts live under
+`notifications/<artifact_group>/<YYYY-MM-DD>/distributor.<run_id>.json`. Batch
+artifacts live under
+`notifications/batches/<batch>/<YYYY-MM-DD>/distributor.<batch_run_id>.json`,
+where the date directory is the batch start date in the effective report
+timezone. The artifact records the rendered pipeline ID, bundle ID,
+idempotency key, managed source paths, bundle-relative paths, bundle created
+timestamp, accepted upload response, and the latest distributor run status
+response when available. Weatherreporter polls status until distributor reports
+`succeeded` or `failed`, or until the configured notification timeout expires.
+The run status includes the distributor status, error text, and raw run report
+JSON, which can show actions such as `replace_older`, `skip_same`,
+`skip_destination_newer`, or `failed`. Token values are not written.
 
 Weatherreporter is responsible for selecting the managed Markdown report,
 constructing a source bundle, and submitting it to the configured distributor
@@ -242,7 +209,7 @@ bundle, so existing uploaded dated report paths can remain available.
 ## Inspection
 
 Inspection commands read existing workspace artifacts and emit JSON to stdout.
-They do not fetch weather data or run `scriptorium`.
+They do not collect weather data or run `scriptorium`.
 
 ```text
 weatherreporter inspect reports --limit 10
@@ -255,23 +222,25 @@ weatherreporter inspect sources RUN_ID
 
 Use `inspect reports` to find RunIDs and artifact paths. Use
 `inspect metadata` to see the artifact links recorded for a run. Use
-`inspect modules` to review the persisted ordered module snapshot, and
-`inspect data-package` to review the structured prompt package used for
-rendering. Use `inspect prior` to see the prior comparable snapshot selected for
-Recent Changes, or `null` when none exists. Use `inspect sources` to review
-source provenance and warnings without dumping full weather payloads.
+`inspect modules` to review the persisted ordered module snapshot with rich
+template-facing values, and `inspect data-package` to review the curated prompt
+package passed to Scriptorium. Use `inspect prior` to see the prior comparable
+snapshot selected for Recent Changes, or `null` when none exists. Use
+`inspect sources` to review source provenance and warnings without dumping full
+weather payloads.
 
 ## Recent Changes
 
 Recent Changes are computed from structured module snapshots, not rendered
 Markdown or YAML text.
 
-Daily Today compares with prior Daily Today snapshots for the same valid local
-date. Tomorrow Report compares with prior Tomorrow Report snapshots for the
-same valid local date. 3-Day Outlook compares with prior compatible 3-Day
-snapshots for the same valid local date. Weekend Outlook compares with prior
-compatible Weekend snapshots for the same weekend window. Hourly Report and
-Storm Report leave Recent Changes empty.
+Daily Report compares with prior Daily Report snapshots for the same valid
+local date. Today Report compares with prior Today Report snapshots for the
+same valid local date. Tomorrow Report compares with prior Tomorrow Report
+snapshots for the same valid local date. 3-Day Outlook compares with prior
+compatible 3-Day snapshots for the same valid local date. Weekend Outlook
+compares with prior compatible Weekend snapshots for the same weekend window.
+Hourly Report and Storm Report leave Recent Changes empty.
 
 When no prior comparable snapshot exists, or no configured threshold is crossed,
 `recentChanges.items` is empty.
@@ -284,14 +253,17 @@ A failed generation run may still leave useful artifacts:
   preflight JSON and metadata are written for inspection.
 - If `scriptorium run` exits nonzero after writing a report, the managed report
   and metadata remain available.
-- Hourly generated-text failures preserve available intermediate artifacts,
-  such as the structured run result, raw generated-text JSON, validated
-  generated text, and render context. Metadata links those paths when it can be
-  safely written.
-- If distributor notification fails, report artifacts and final metadata remain
-  available, but the report or batch command returns nonzero.
+- Generated-text failures for Daily, Today, Tomorrow, and Hourly reports preserve
+  available intermediate artifacts, such as the structured run result, raw
+  generated-text JSON, validated generated text, and render context. Metadata
+  links those paths when it can be safely written.
+- If single-report distributor notification fails, report artifacts and final
+  metadata remain available, but the report command returns nonzero.
+- If batch distributor notification fails, report artifacts and final metadata
+  remain available, the top-level batch notification links the debug artifact,
+  and the batch command returns nonzero.
 - For batch commands, inspect the stdout JSON summary first, then inspect the
-  artifact paths for each failed report.
+  artifact paths for each failed report or the top-level notification path.
 
 For a bad report, start with:
 

docs/policy/development.md

@@ -121,8 +121,12 @@ The CLI is owned by `internal/cli`.
 When adding or changing a command or flag:
 
 - update help text and parser behavior together;
+- declare whether the command is an action command or an inspection/data-output
+  command;
 - convert parsed values into app-layer request structs;
 - keep domain decisions in `internal/app` or domain packages;
+- use the centralized output helpers in `internal/cli/output.go`;
+- keep action-command summary conversion in `internal/cli/result.go`;
 - add parser or command tests in `internal/cli`;
 - update `docs/cli.md`;
 - update `docs/operations.md` or `docs/troubleshooting.md` when behavior affects

docs/roadmap/future.md

@@ -5,18 +5,22 @@ documented outside `docs/roadmap/`.
 
 ## Automatic Storm Monitoring
 
-Manual Storm Report generation is implemented through
-`weatherreporter generate storm --start TIME --end TIME`. Automatic storm-event
-evaluation remains deferred.
+Manual Storm Report generation is available through:
 
-Proposed direction:
+```sh
+weatherreporter generate storm --start TIME --end TIME
+```
 
-1. detect candidate events deterministically from alerts, forecast discussion,
-   weather story context, hourly thresholds, and material forecast changes;
-2. evaluate candidates through Scriptorium or another narrow evaluator adapter;
-3. persist storm lifecycle state;
-4. generate or update Storm Reports only when a meaningful event is present;
-5. suppress ordinary low-impact thunder or rain chances.
+Automatic storm-event evaluation is not implemented.
+
+Possible direction:
+
+1. Detect candidate storm events from alerts, forecast discussion, weather
+   story context, hourly thresholds, and material forecast changes.
+2. Evaluate candidates through Scriptorium or another narrow evaluator adapter.
+3. Persist storm lifecycle state.
+4. Generate or update Storm Reports only when a meaningful event is present.
+5. Suppress ordinary low-impact thunder or rain chances.
 
 Possible lifecycle states:
 
@@ -27,41 +31,41 @@ Possible lifecycle states:
 - `deescalating`
 - `resolved`
 
-Acceptance criteria before implementation:
+Before implementation, the design must preserve scheduled report behavior,
+manual Storm Report generation, inspectable evaluator failures, and fixture
+coverage for deterministic candidate detection.
 
-- scheduled reports and manual Storm Reports remain stable;
-- candidate detection has fixture coverage;
-- evaluator failures are inspectable and do not create noisy report output;
-- manual Storm Report generation remains available.
-
-## Future Report Types And Modules
-
-The module-based prompt package architecture is implemented. Future work should
-add only modules backed by implemented upstream facts and clear report needs.
+## Future Report Types
 
 Possible future report types:
 
-- another short-fuse planning report distinct from the implemented Hourly
-  Report, if a separate product is needed;
-- event-specific reports with stable event IDs;
-- storm review or yesterday-style reports using historical observations;
+- a short-fuse planning report distinct from the implemented Hourly Report, if
+  a separate product is needed
+- event-specific reports with stable event IDs
+- storm review or yesterday-style reports using historical observations
 - archive-focused report variants if generated report history becomes a
-  first-class product.
+  first-class product
+
+New reports should keep report identity, prompt IDs, templates, valid-period
+resolution, artifact grouping, batch output names, and comparison policy inside
+`internal/report`.
+
+## Future Modules
 
 Possible future modules:
 
-- `hourly_table` for compact valid-period hourly facts;
+- `hourly_table` for compact valid-period hourly facts
 - `forecast_delta` if a separate stanza is useful beyond current Recent
-  Changes;
+  Changes
 - `weekend_planning` if weekend-specific planning guidance needs a dedicated
-  deterministic stanza;
+  deterministic stanza
 - `storm_window_summary` if manual or automatic Storm Reports need a dedicated
-  prompt-facing storm-window module;
+  prompt-facing storm-window module
 - separate AFD section aliases, such as `afd_key_messages`,
   `afd_short_term_text`, and `afd_long_term_text`, if separate stanzas prove
-  more useful than `area_forecast_discussion.options.sections`;
+  more useful than `area_forecast_discussion.options.sections`
 - SPC, radar, QPF, snow/rain total, or historical-observation modules once
-  upstream sources and report requirements exist.
+  upstream sources and report requirements exist
 
 QPF fields such as `measurable_qpf_total_in` and `max_hourly_qpf_in` should
 remain omitted until a real upstream quantitative precipitation source is
@@ -69,79 +73,61 @@ represented in `CollectedFacts`.
 
 Future module work should preserve these boundaries:
 
-- collect upstream facts once per report run;
-- keep upstream fetching out of modules;
-- keep broad reusable calculations in `DerivedFacts`;
-- keep prompt-facing field shape inside module builders;
-- use typed options for configurable module behavior;
-- keep module snapshots structured and deterministic for Recent Changes.
+- keep upstream collection in app orchestration
+- keep upstream collection out of modules
+- keep broad reusable calculations in `DerivedFacts`
+- keep prompt-facing field shape inside module builders
+- use typed options for configurable module behavior
+- keep module snapshots structured and deterministic for Recent Changes
 
 ## Distributor Notification Enhancements
 
-Distributor notification currently uploads one managed Markdown report per
-successful generated report through the configured HTTP upload pipeline.
+Distributor notification uploads one managed Markdown report per successful
+generated report through the configured HTTP upload pipeline. The following
+enhancements are not implemented:
 
-These enhancements are not current behavior:
+- `failure_policy: warn`
+- uploading metadata, module snapshots, data packages, or preflight artifacts
+- durable upload retry queues
+- distributor-specific CLI flags
+- distributor workspace scanning
+- destination routing, Markdown-to-HTML transformation, public URLs, or nginx
+  layout inside weatherreporter
 
-- `failure_policy: warn`;
-- uploading metadata, module snapshots, data packages, or preflight artifacts;
-- durable upload retry queues;
-- distributor-specific CLI flags;
-- making distributor scan the weatherreporter workspace;
-- handling destination routing, Markdown-to-HTML transformation, public URLs,
-  or nginx layout inside weatherreporter.
-
-Any distributor enhancement should preserve the existing adapter boundary:
+Any distributor enhancement should preserve the adapter boundary:
 weatherreporter selects explicit generated files and submits source bundles,
 while distributor owns destination routing and publication behavior.
 
 ## Alternate Runtime Integrations
 
-These ideas are not current behavior:
+These ideas are not implemented:
 
-- native LLM client inside `weatherreporter`;
-- database-backed state;
-- public HTTP API;
-- multi-location selection;
-- daemon mode;
-- multi-user authorization;
-- plugin system;
-- dynamic module loading;
-- user-defined module code;
-- YAML-defined module schemas;
-- module-owned Weather API fetching.
+- native LLM client inside `weatherreporter`
+- database-backed state
+- public HTTP API
+- multi-location selection
+- daemon mode
+- multi-user authorization
+- plugin system
+- dynamic module loading
+- user-defined module code
+- YAML-defined module schemas
+- module-owned Weather API fetching
 
 Each item needs its own design note before implementation. Non-roadmap docs
 must not describe these as available behavior.
 
-## Cleanup Refactors
+## Deferred Refactors
 
-The initial cleanup pass intentionally left these refactors out because the
-current implementation does not yet make them worth the added abstraction.
+These refactors should remain deferred until new requirements or recurring
+maintenance costs make the added abstraction worthwhile:
 
-Revisit these only when new source types, report types, operational
-requirements, or recurring maintenance costs make the duplication materially
-more expensive:
-
-- Weather API optional-source specification/helper refactor: consider when
-  additional Weather API sources make per-source fan-out, policy handling, and
-  provenance wiring repetitive enough to obscure adapter behavior.
-- Broad briefing weather-signal consolidation: consider when multiple module
-  builders repeatedly derive the same weather signals and tests begin to need
-  coordinated fixture updates.
-- Generic workflow engine: defer unless generation, inspection, recovery, or
-  future background workflows gain enough shared step semantics to justify a
-  declared execution model.
-- Cobra migration: defer while the standard-library CLI remains small,
-  explicit, and covered by parser tests.
-- Manifest, resume, or progress system: defer until operators need resumable
-  runs, checkpoint recovery, or richer audit trails than the current durable
-  artifacts and metadata provide.
-- Global test helper package: defer while package-local helpers keep tests
-  clear; revisit only if setup duplication starts to hide behavior.
-- Logging subsystem: defer until there are recurring operator diagnostics that
-  cannot be handled with current errors, metadata, inspection commands, and
-  artifact output.
+- broad briefing weather-signal consolidation
+- generic workflow engine
+- Cobra migration
+- manifest, resume, or progress system
+- global test helper package
+- logging subsystem
 
 Any future implementation should preserve the existing public CLI, artifact
 paths, report identities, module boundaries, and adapter boundaries unless a

docs/roadmap/implementation.md

@@ -1,441 +0,0 @@
-# Tomorrow Report Implementation Roadmap
-
-## Purpose
-
-This roadmap defines the staged implementation plan for
-`docs/roadmap/tomorrow.md`. It is written for an LLM coding agent that will
-implement each stage in order. The conceptual target state, user intent, and
-locked product decisions live in `docs/roadmap/tomorrow.md`; this file defines
-the concrete implementation sequence.
-
-This is future-work planning. Do not treat the behavior described here as
-implemented until the corresponding code, tests, examples, and non-roadmap docs
-are updated.
-
-## Implementation Guardrails
-
-- Preserve public CLI syntax: `weatherreporter generate tomorrow`.
-- Make a clean pre-release break from report ID `daily_tomorrow`; do not add
-  compatibility aliases.
-- Keep report identity, prompt IDs, template IDs, artifact groups, output names,
-  and comparison policy centralized in `internal/report`.
-- Reuse the existing `generated_text_template` workflow implemented for Hourly.
-- Keep Scriptorium details behind the existing adapter boundary.
-- Keep Go responsible for deterministic facts, valid periods, module snapshots,
-  structured generated-text validation, and final Markdown template rendering.
-- Keep templates responsible for wording and layout.
-- Keep generated JSON schemas and Markdown templates as embedded asset files,
-  not inline Go strings.
-- Preserve current managed artifact behavior except where report identity
-  intentionally changes from `daily_tomorrow` to `tomorrow`.
-
-## Stage 1: Report Identity Split
-
-Goal: make Tomorrow an independent report ID and artifact identity while
-preserving the public `generate tomorrow` command.
-
-Implementation:
-
-- Replace `report.DailyTomorrow` with `report.Tomorrow` whose value is
-  `"tomorrow"`.
-- Rename report-definition helpers and resolvers around the new identity:
-  `dailyTomorrowDefinition` to `tomorrowDefinition`,
-  `dailyTomorrowModules` to `tomorrowModules`, and
-  `resolveDailyTomorrow` to `resolveTomorrow`.
-- Update `report.DefaultRegistry`, `Registry.All`, batch resolution, and tests
-  so the built-in report order contains `tomorrow` instead of
-  `daily_tomorrow`.
-- Update `internal/app` so `app.ReportTomorrow` resolves to `report.Tomorrow`.
-- Keep the valid period as the next local civil day.
-- Keep evening batch behavior: `run evening` should still generate the Tomorrow
-  report.
-- Change Tomorrow definition identity fields to:
-  - `ID: report.Tomorrow`
-  - `Name: "Tomorrow Report"`
-  - `ArtifactGroup: "tomorrow"`
-  - `BatchOutputName: "tomorrow.md"`
-  - `Generated: true`
-  - `CompatiblePriorIDs: []report.ID{report.Tomorrow}`
-  - `ComparisonStrategy: report.CompareSameValidDate`
-- Keep the current Tomorrow module composition initially, renamed to
-  `tomorrowModules`, so the prompt data package continues to include the
-  daypart, precipitation, alert, SPC, AFD, weather story, tomorrow planning,
-  and hourly facts already available.
-- Update all code and tests that assert `daily_tomorrow` paths, metadata,
-  RunIDs, prior compatibility, or registry IDs.
-
-Acceptance criteria:
-
-- No production-code references to `report.DailyTomorrow` or report ID
-  `daily_tomorrow` remain.
-- `weatherreporter generate tomorrow` still parses and resolves successfully.
-- Evening batch contains `tomorrow`.
-- Managed workspace artifact paths and distributor identity values now use
-  `tomorrow`.
-
-Suggested validation:
-
-```bash
-go test ./internal/report ./internal/app ./internal/cli ./internal/state
-```
-
-This stage is suitable for one implementation prompt.
-
-## Stage 2: Tomorrow GeneratedText Contract
-
-Goal: add structured Tomorrow LLM output validation and schema assets.
-
-Implementation:
-
-- Add `internal/generatedtext/tomorrow.go` with:
-
-```go
-type Tomorrow struct {
-    Summary             string   `json:"summary"`
-    ForecastDiscussion  []string `json:"forecast_discussion"`
-    PrecipitationTiming string   `json:"precipitation_timing,omitempty"`
-    Confidence          string   `json:"confidence,omitempty"`
-}
-```
-
-- Add `generatedtext.ValidateTomorrow`.
-- Use `json.Decoder.DisallowUnknownFields`.
-- Reject multiple JSON values.
-- Trim `Summary`, `PrecipitationTiming`, `Confidence`, and each
-  `ForecastDiscussion` paragraph.
-- Drop blank discussion paragraphs after trimming, then require at least one
-  remaining paragraph.
-- Reject blank `Summary`.
-- Return normalized JSON with the same public field names.
-- Add `internal/reporttemplate/schemas/tomorrow.generated_text.schema.json`.
-  The schema should:
-  - require `summary`;
-  - require `forecast_discussion`;
-  - define `forecast_discussion` as an array of strings with at least one item;
-  - allow optional `precipitation_timing` and `confidence`;
-  - reject additional properties.
-- Add `internal/reporttemplate/prompts/tomorrow.generated_text.md` as the
-  maintained Scriptorium prompt source asset. This file is a source contract for
-  out-of-band Scriptorium prompt registration; weatherreporter does not need to
-  load prompt Markdown at runtime.
-- Add Tomorrow to `internal/reporttemplate` schema lookup.
-- Update app generated-text validation dispatch so it can return either
-  `generatedtext.Hourly` or `generatedtext.Tomorrow`. Prefer a small generic
-  dispatch shape such as:
-
-```go
-func validateGeneratedText(def report.Definition, data []byte) (any, []byte, error)
-```
-
-  Then type-check the returned value in render-context dispatch.
-
-Acceptance criteria:
-
-- Tomorrow generated text rejects unknown fields, missing required fields,
-  blank summary, and no usable forecast discussion paragraphs.
-- Optional `precipitation_timing` and `confidence` are trimmed and omitted from
-  normalized JSON when empty.
-- Hourly generated text behavior is unchanged.
-
-Suggested validation:
-
-```bash
-go test ./internal/generatedtext ./internal/reporttemplate ./internal/app
-```
-
-This stage is suitable for one implementation prompt.
-
-## Stage 3: Daypart Presentation Fields
-
-Goal: add only the daypart fields needed to keep the Tomorrow template
-composable without moving prose construction into Go.
-
-Implementation:
-
-- Extend the `derived_daypart_summaries` module output with presentation
-  helpers that are facts, not complete sentences:
-  - `display_name`, for example `Morning`;
-  - `dominant_condition_lower`, for inline template text;
-  - `temperature_phrase_f`, such as `low 70s`, `upper 60s`, or
-    `upper 60s to mid-70s`;
-  - `mention_precipitation`, true when max PoP is at or above the existing
-    hourly forecast precipitation mention threshold, currently 20%;
-  - `max_pop_time_label`, using friendly local hour format such as `8:00 AM`
-    when max PoP time exists.
-- Reuse the existing hourly forecast precipitation mention threshold constant
-  rather than adding a user config field in this change.
-- Keep existing structured numeric fields in the module output.
-- Do not add a prewritten `daypart_line` string.
-- Do not add wind prose in this stage unless tests show the initial template
-  needs a specific structured wind fact. If wind wording is needed, add a
-  small structured wind field, not a full sentence.
-
-Acceptance criteria:
-
-- Daypart module output has enough structured fields for a readable Tomorrow
-  template.
-- The output remains useful for YAML prompt packages.
-- No generated prose sentence is hard-coded into the module.
-
-Suggested validation:
-
-```bash
-go test ./internal/briefing ./internal/promptinput
-```
-
-This stage is suitable for one implementation prompt.
-
-## Stage 4: Tomorrow Render Context And Template
-
-Goal: render Tomorrow Markdown from structured generated text, module outputs,
-and report metadata.
-
-Implementation:
-
-- Add a dedicated Tomorrow render context under `internal/generatedtext`, for
-  example:
-
-```go
-type TomorrowRenderContext struct {
-    Report        TomorrowReportContext
-    GeneratedText Tomorrow
-    Modules       TomorrowTemplateModules
-    Collected     facts.CollectedFacts
-    Derived       facts.DerivedFacts
-}
-```
-
-- Add `TomorrowReportContext` with:
-  - `Title`, for example `Sunday's Weather`;
-  - `ForecastDate`;
-  - `ForecastDateLabel`, for example `Sunday, June 15, 2026`;
-  - `ForecastDayName`, for example `Sunday`;
-  - `GeneratedAt`;
-  - `GeneratedAtLabel`, for example
-    `Saturday, June 14, 2026 at 9:14 AM`;
-  - `ValidPeriod`;
-  - `Timezone`.
-- Construct `Title` in Go, not in the template.
-- Add `TomorrowTemplateModules` with pointer fields for the module outputs used
-  by the template:
-  - `Metadata`;
-  - `DerivedDailySummary`;
-  - `DerivedDaypartSummaries`;
-  - `PrecipTiming`;
-  - `AlertDigest`;
-  - `SPCConvectiveOutlooks`;
-  - `AreaForecastDiscussion`;
-  - `SPCConvectiveDiscussion`;
-  - `WeatherStory`;
-  - `TomorrowPlanning`.
-- Add an ordered daypart slice for the template, derived from the configured
-  daypart order rather than ranging directly over a map. This can live in
-  `TomorrowTemplateModules`, for example `Dayparts []TomorrowDaypartContext`.
-- Add `BuildTomorrowRenderContext`.
-- Add `internal/reporttemplate/templates/tomorrow.md.tmpl`.
-- Add Tomorrow to `internal/reporttemplate` template lookup.
-- Template shape:
-  - title;
-  - forecast date;
-  - generated timestamp;
-  - `GeneratedText.Summary`;
-  - deterministic `Daypart Forecast` bullets in configured order;
-  - conditional `Precipitation Timing` only when precipitation windows exist;
-  - deterministic precipitation window bullets before optional
-    `GeneratedText.PrecipitationTiming`;
-  - `Forecast Discussion` with one paragraph per
-    `GeneratedText.ForecastDiscussion` item.
-- Keep current conditions and hourly forecast available through the data
-  package and render context, but do not render them in the initial Tomorrow
-  template unless the template explicitly uses them.
-
-Acceptance criteria:
-
-- The template renders without map-order nondeterminism.
-- Precipitation Timing is omitted when no precipitation windows exist.
-- Forecast Discussion supports multiple paragraphs.
-- Missing optional modules produce clean omission or fallback behavior, not
-  template execution errors.
-
-Suggested validation:
-
-```bash
-go test ./internal/generatedtext ./internal/reporttemplate ./internal/briefing
-```
-
-This stage is suitable for one implementation prompt.
-
-## Stage 5: App Workflow Integration
-
-Goal: route Tomorrow through the generated-text-template workflow end to end.
-
-Implementation:
-
-- Change Tomorrow report definition to:
-  - `PromptID: "weather.tomorrow_generated_text"`
-  - `GenerationMode: report.GenerationModeGeneratedTextTemplate`
-  - `TemplateID: "tomorrow"`
-  - `GeneratedTextSchemaID: "tomorrow"`
-- Update `internal/app.buildRenderContext` dispatch:
-  - hourly template requires `generatedtext.Hourly`;
-  - tomorrow template requires `generatedtext.Tomorrow`;
-  - unsupported type/template combinations return actionable errors.
-- Ensure Scriptorium `run` writes raw generated text to a `.json` path for
-  Tomorrow, matching the existing generated-text-template workflow.
-- Ensure normalized generated text, render context JSON, generated Markdown,
-  metadata, and final report artifacts are persisted through existing state
-  helpers.
-- Ensure app errors include report ID `tomorrow` and RunID context.
-
-Acceptance criteria:
-
-- `weatherreporter generate tomorrow` no longer invokes Scriptorium for full
-  Markdown.
-- The workflow validates Scriptorium JSON output, builds a Tomorrow render
-  context, and renders Markdown locally.
-- Hourly generated-text-template behavior remains unchanged.
-
-Suggested validation:
-
-```bash
-go test ./internal/app ./internal/state ./internal/adapters/scriptorium
-```
-
-This stage is suitable for one implementation prompt.
-
-## Stage 6: CLI, State, Distributor, And Batch Behavior
-
-Goal: update cross-package behavior affected by the report ID clean break.
-
-Implementation:
-
-- Update CLI tests and command-output expectations for `generate tomorrow`.
-- Update state/path tests so managed artifacts, snapshots, data packages,
-  generated-text artifacts, render contexts, and report files use artifact group
-  `tomorrow`.
-- Update batch tests:
-  - evening batch emits report ID `tomorrow`;
-  - batch output copy name remains `tomorrow.md`;
-  - partial-failure behavior is unchanged.
-- Update Recent Changes tests:
-  - Tomorrow compares only against prior `tomorrow` snapshots;
-  - Daily Today no longer treats Tomorrow as a compatible prior unless the
-    implementation explicitly keeps that relationship for Daily Today only.
-- Update distributor notification tests so rendered template variables use:
-  - `report_id=tomorrow`;
-  - `artifact_group=tomorrow`;
-  - `batch_output_name=tomorrow.md`.
-- Update config tests so report module overrides use `reports.tomorrow`.
-  Do not accept `reports.daily_tomorrow` unless a future explicit
-  compatibility decision reverses the clean break.
-
-Acceptance criteria:
-
-- Public CLI syntax is stable.
-- Persisted artifacts and distributor request context use the new report ID.
-- Batch behavior is unchanged except for the new ID.
-- No tests rely on `daily_tomorrow`.
-
-Suggested validation:
-
-```bash
-go test ./internal/cli ./internal/app ./internal/state ./internal/config ./internal/report
-```
-
-This stage is suitable for one implementation prompt.
-
-## Stage 7: Documentation And Examples
-
-Goal: align implemented docs and maintained examples after the code change.
-
-Implementation:
-
-- Update non-roadmap docs only after the behavior is implemented.
-- Inspect and update:
-  - `docs/cli.md`;
-  - `docs/config.md`;
-  - `docs/operations.md`;
-  - `docs/troubleshooting.md`, if new failure modes are introduced;
-  - `docs/internal/report-registry.md`;
-  - `docs/internal/generatedtext.md`;
-  - `docs/internal/reporttemplate.md`;
-  - `docs/internal/state.md`;
-  - `docs/templates.md`;
-  - relevant Scriptorium and distributor integration docs only if their
-    weatherreporter-facing contract changed.
-- Update `examples/config.yml` if it references Tomorrow modules or
-  `reports.daily_tomorrow`.
-- Keep future Today/Daily split language only under `docs/roadmap/`.
-- Do not document unimplemented Today or generic Daily products as current
-  behavior.
-
-Acceptance criteria:
-
-- Non-roadmap docs describe implemented behavior only.
-- Docs use report ID `tomorrow`.
-- Examples load under current config validation.
-- No stale user-facing references to `daily_tomorrow` remain outside historical
-  roadmap context.
-
-Suggested validation:
-
-```bash
-rg -n "daily_tomorrow|Daily Tomorrow|weather.daily_report" README.md docs examples internal
-git diff --check
-```
-
-This stage is suitable for one implementation prompt.
-
-## Stage 8: Final Validation
-
-Goal: verify the completed cutover as a coherent behavior change.
-
-Run:
-
-```bash
-go test ./internal/report ./internal/generatedtext ./internal/reporttemplate ./internal/briefing ./internal/app ./internal/cli ./internal/state
-go test ./...
-go run ./cmd/weatherreporter --help
-git diff --check
-```
-
-Also run targeted stale-symbol checks:
-
-```bash
-rg -n "DailyTomorrow|dailyTomorrow|daily_tomorrow" internal docs examples
-rg -n "weather.tomorrow_generated_text|TemplateID:.*tomorrow|GeneratedTextSchemaID:.*tomorrow" internal docs
-```
-
-Acceptance criteria:
-
-- Full test suite passes.
-- Help output still shows `generate tomorrow`.
-- No production-code stale `daily_tomorrow` symbols remain.
-- Generated-text-template artifacts for Tomorrow are persisted in the same
-  categories as Hourly.
-- Existing Hourly behavior still passes tests.
-
-This stage is suitable for one implementation prompt.
-
-## Open Questions
-
-None block implementation. The required decisions are locked by
-`docs/roadmap/tomorrow.md` and this implementation plan:
-
-- Tomorrow uses report ID `tomorrow`.
-- Tomorrow uses prompt ID `weather.tomorrow_generated_text`.
-- Tomorrow uses template ID and generated-text schema ID `tomorrow`.
-- Tomorrow forecast discussion is an array of paragraph strings.
-- `daily_tomorrow` compatibility aliases are intentionally not preserved.
-
-## Global Validation Checklist
-
-- `go test ./...`
-- `go run ./cmd/weatherreporter --help`
-- `git diff --check`
-- `rg -n "DailyTomorrow|dailyTomorrow|daily_tomorrow" internal docs examples`
-- Confirm `weatherreporter generate tomorrow` uses structured JSON from
-  Scriptorium and renders final Markdown locally.
-- Confirm distributor notification context uses `report_id=tomorrow` and
-  `artifact_group=tomorrow`.
-- Confirm examples contain no unimplemented fields and no secrets.

docs/roadmap/tomorrow.md

@@ -1,276 +0,0 @@
-# Tomorrow Report Roadmap
-
-## Purpose
-
-This roadmap defines the target state for making Tomorrow an independent
-generated-text-template report. The feature is not implemented yet, so this
-document lives under `docs/roadmap/`.
-
-## Intent
-
-Tomorrow should become its own report product, not a variant of the Daily
-Report. The current CLI command `weatherreporter generate tomorrow` should
-remain, but the internal report ID, prompt ID, template, schema, workspace
-paths, and distributor identity should use `tomorrow`.
-
-The report should combine deterministic daypart and precipitation facts with
-LLM prose for the high-level summary, optional precipitation context, and
-forecast discussion. The resulting Markdown should be predictable and
-template-driven, similar to the implemented Hourly Report.
-
-Longer term, Today, Tomorrow, and Daily may all become separate report products
-with different prompts, templates, and deterministic sections. This roadmap
-starts that split with Tomorrow.
-
-## Target Report Shape
-
-Example structure:
-
-```markdown
-# Sunday's Weather
-
-**Forecast Date:** Sunday, June 15, 2026
-**Generated:** Saturday, June 14, 2026 at 9:14 AM
-
-<GeneratedText summary>
-
-## Daypart Forecast
-
-- **Overnight:** <deterministic daypart line>
-- **Morning:** <deterministic daypart line>
-- **Midday:** <deterministic daypart line>
-- **Afternoon:** <deterministic daypart line>
-- **Evening:** <deterministic daypart line>
-
-## Precipitation Timing
-
-- **1:00 AM** to **5:00 AM**: Precipitation is expected during this period. The peak precipitation chance is 59% at 2:00 AM.
-- <optional GeneratedText precipitation_timing>
-
-## Forecast Discussion
-
-<GeneratedText forecast_discussion paragraphs>
-```
-
-`Precipitation Timing` should render only when at least one precipitation
-window exists for the valid period. The threshold for precipitation windows
-remains the existing precipitation-window threshold, currently 40%.
-
-## Locked Decisions
-
-- Replace report ID `daily_tomorrow` with `tomorrow`.
-- Do not preserve compatibility aliases for `daily_tomorrow`; this is a
-  pre-release clean break.
-- Keep public CLI syntax: `weatherreporter generate tomorrow`.
-- Use generated-text-template generation for Tomorrow, not full Markdown
-  generation by Scriptorium.
-- Use a dedicated Scriptorium prompt ID, template ID, and schema ID:
-  - prompt ID: `weather.tomorrow_generated_text`
-  - template ID: `tomorrow`
-  - generated-text schema ID: `tomorrow`
-- Use `ArtifactGroup: "tomorrow"` and `BatchOutputName: "tomorrow.md"`.
-- Use `CompatiblePriorIDs: []report.ID{report.Tomorrow}`.
-- Keep valid-period behavior: Tomorrow covers the next local civil day.
-- Keep Morning/Evening batch behavior unless explicitly changed later; evening
-  batch should still include Tomorrow.
-- Future Today/Daily split is out of scope for this roadmap.
-
-## GeneratedText Contract
-
-Add a Tomorrow GeneratedText schema:
-
-```json
-{
-  "summary": "string",
-  "forecast_discussion": ["string"],
-  "precipitation_timing": "string",
-  "confidence": "string"
-}
-```
-
-Required:
-
-- `summary`
-- `forecast_discussion`
-
-Optional:
-
-- `precipitation_timing`
-- `confidence`
-
-`forecast_discussion` should be an array of paragraph strings so Scriptorium
-can return multi-paragraph discussion without embedding paragraph delimiters in
-one string. Empty or whitespace-only discussion paragraphs should be rejected or
-trimmed out during validation; after trimming, at least one paragraph is
-required.
-
-`confidence` may be validated and persisted but does not need to render in the
-initial template.
-
-## Template Context
-
-Add a dedicated Tomorrow render context rather than reusing Hourly context
-types.
-
-Recommended top-level shape:
-
-```go
-type TomorrowRenderContext struct {
-    Report        TomorrowReportContext
-    GeneratedText Tomorrow
-    Modules       TomorrowTemplateModules
-    Collected     facts.CollectedFacts
-    Derived       facts.DerivedFacts
-}
-```
-
-`TomorrowReportContext` should include:
-
-- `Title`: for example `Sunday's Weather`
-- `ForecastDate`: canonical local forecast date if useful
-- `ForecastDateLabel`: for example `Sunday, June 15, 2026`
-- `ForecastDayName`: for example `Sunday`
-- `GeneratedAt`
-- `GeneratedAtLabel`: for example `Saturday, June 14, 2026 at 9:14 AM`
-- `ValidPeriod`
-- `Timezone`
-
-Do not derive the possessive title in the template. Go should provide `Title`
-so wording is consistent and easy to test.
-
-`TomorrowTemplateModules` should expose the module outputs needed by the
-template:
-
-- `Metadata`
-- `DerivedDailySummary`
-- `DerivedDaypartSummaries`
-- `PrecipTiming`
-- `AlertDigest`
-- `SPCConvectiveOutlooks`
-- `AreaForecastDiscussion`
-- `SPCConvectiveDiscussion`
-- `WeatherStory`
-- `TomorrowPlanning`, if still useful
-
-Current conditions and hourly forecast can remain in the module snapshot and
-data package if useful for Scriptorium, but they do not need to render in the
-initial Tomorrow template unless a later design calls for them.
-
-## Daypart Forecast
-
-The Daypart Forecast should be deterministic but composable. Avoid adding a
-single prewritten Go `DaypartLine` string that makes template wording rigid.
-
-Add presentation-friendly fields to `derived_daypart_summaries` only where they
-avoid awkward template logic. Likely useful fields:
-
-- display name, such as `Overnight` or `Morning`;
-- lower-case dominant condition text for inline sentences;
-- rounded temperature range phrase if available;
-- precipitation mention flag using the existing hourly line mention threshold
-  concept, currently 20%;
-- max precipitation probability and friendly max time;
-- optional wind phrase or wind range only if deterministic wind wording is
-  clearly needed.
-
-The initial implementation may keep daypart bullet wording simple. It should be
-easy to revise the template text without editing Go unless new facts are
-needed.
-
-## Implementation Plan
-
-1. Report identity split
-   - Rename `report.DailyTomorrow` to `report.Tomorrow` with ID `tomorrow`.
-   - Update registry order, resolver references, CLI mapping, batch selection,
-     state metadata expectations, docs, and tests.
-   - Preserve `weatherreporter generate tomorrow`.
-   - Accept that workspace paths, RunIDs, distributor bundle IDs, and report
-     URLs change from `daily_tomorrow` to `tomorrow`.
-
-2. GeneratedText contract
-   - Add `generatedtext.Tomorrow`, validation, normalized JSON output, and
-     tests.
-   - Add `tomorrow.generated_text.schema.json`.
-   - Add `internal/reporttemplate/prompts/tomorrow.generated_text.md` as the
-     maintained prompt source asset.
-   - Update app validation dispatch to use the Tomorrow schema.
-
-3. Template and render context
-   - Add `internal/reporttemplate/templates/tomorrow.md.tmpl`.
-   - Add Tomorrow template/schema lookup entries.
-   - Add `BuildTomorrowRenderContext`.
-   - Update app render-context dispatch for template ID `tomorrow`.
-   - Persist render context in the existing generated-text-template workflow.
-
-4. Module presentation fields
-   - Add only the daypart presentation fields needed by the template.
-   - Reuse the existing precipitation window hour-label fields.
-   - Keep deterministic weather derivation in Go and wording/layout in the
-     template.
-
-5. Report definition conversion
-   - Change Tomorrow report definition to:
-     - `PromptID: "weather.tomorrow_generated_text"`
-     - `GenerationMode: generated_text_template`
-     - `TemplateID: "tomorrow"`
-     - `GeneratedTextSchemaID: "tomorrow"`
-     - `ArtifactGroup: "tomorrow"`
-     - `BatchOutputName: "tomorrow.md"`
-     - compatible prior IDs containing only `tomorrow`
-   - Review module composition and keep only modules used by the prompt,
-     template, or future inspection value.
-
-6. Documentation and examples
-   - After implementation, update non-roadmap docs for implemented behavior:
-     `docs/cli.md`, `docs/operations.md`, `docs/internal/report-registry.md`,
-     `docs/internal/generatedtext.md`, `docs/internal/reporttemplate.md`, and
-     `docs/templates.md`.
-   - Update examples that refer to `reports.tomorrow` or report module
-     overrides if the config key changes.
-
-## Test Plan
-
-- Report tests:
-  - registry contains `tomorrow`, not `daily_tomorrow`;
-  - `generate tomorrow` resolves report ID `tomorrow`;
-  - valid period remains next local civil day;
-  - evening batch still includes Tomorrow;
-  - RunID and artifact paths use `tomorrow`.
-- GeneratedText tests:
-  - `summary` and non-empty `forecast_discussion` are required;
-  - `forecast_discussion` trims paragraph strings and rejects/omits blanks;
-  - optional `precipitation_timing` and `confidence` normalize correctly;
-  - unknown fields are rejected.
-- Template tests:
-  - title renders as `<weekday>'s Weather`;
-  - forecast date and generated labels render;
-  - daypart bullets render in configured daypart order;
-  - precipitation section is omitted when no precipitation windows exist;
-  - precipitation section includes deterministic windows and optional LLM text
-    when windows exist;
-  - forecast discussion renders multiple paragraphs.
-- App/CLI workflow tests:
-  - `weatherreporter generate tomorrow` uses structured Scriptorium output and
-    the template renderer;
-  - raw generated text, validated generated text, render context, report, and
-    metadata artifacts are persisted;
-  - optional `--out` behavior remains unchanged;
-  - distributor notification uses report ID/artifact group `tomorrow`.
-
-Validation commands:
-
-```bash
-go test ./internal/report ./internal/generatedtext ./internal/reporttemplate ./internal/briefing ./internal/app ./internal/cli ./internal/state
-go test ./...
-go run ./cmd/weatherreporter --help
-git diff --check
-```
-
-## Open Questions
-
-None block implementation. Recommended defaults are:
-
-- make `forecast_discussion` an array of strings for Tomorrow;
-- keep Hourly GeneratedText unchanged for now;
-- do not add Daily Today or generic Daily report splits in this change;
-- do not preserve `daily_tomorrow` compatibility aliases.

docs/templates.md

@@ -6,15 +6,26 @@ This guide describes the implemented Markdown report template surface for
 `weatherreporter`. It is for maintainers editing embedded report templates,
 especially generated-text-template reports.
 
-Templates are Go `text/template` files. The current implemented templates are:
+Templates are Go `text/template` files. The implemented top-level templates
+are:
 
+- `internal/reporttemplate/templates/daily.md.tmpl`
+- `internal/reporttemplate/templates/today.md.tmpl`
 - `internal/reporttemplate/templates/tomorrow.md.tmpl`
 - `internal/reporttemplate/templates/hourly.md.tmpl`
 
-Templates are rendered from structured contexts such as `TomorrowRenderContext`
-and `HourlyRenderContext`. Weather data collection, derivation, module
-execution, generated text validation, and artifact paths are handled before
-template rendering.
+Shared named partials live under `internal/reporttemplate/templates/partials/`:
+
+- `alert_digest.md.tmpl`, used by Daily, Today, Tomorrow, and Hourly for the
+  combined Alerts and Risk Products section
+- `daypart_forecast.md.tmpl`, used by Daily and Tomorrow
+- `today_daypart_forecast.md.tmpl`, used by Today
+- `precipitation_timing.md.tmpl`, used by Daily, Today, Tomorrow, and Hourly
+
+Templates are rendered from structured contexts such as `DailyRenderContext`,
+`TodayRenderContext`, `TomorrowRenderContext`, and `HourlyRenderContext`.
+Weather data collection, derivation, module execution, generated text
+validation, and artifact paths are handled before template rendering.
 
 ## Editing Rules
 
@@ -24,7 +35,10 @@ template rendering.
 - Do not put weather derivation, source selection, or path construction logic in
   templates.
 - Missing template keys are errors. A misspelled variable will fail rendering.
-- No custom template functions are currently registered.
+- No custom template functions are registered.
+- Named partials are invoked with `{{ template "name" . }}`. Pass the current
+  render context (`.`) unless the partial is intentionally designed for a
+  narrower value.
 - Optional module stanzas are pointers and should be guarded with
   `{{ with .Modules.WeatherStory }}...{{ end }}`.
 - Slices can be rendered with `{{ range .Items }}...{{ else }}...{{ end }}`.
@@ -101,6 +115,9 @@ Tomorrow generated text uses the same `.GeneratedText.Summary`,
 Hourly. `.GeneratedText.ForecastDiscussion` is a slice of paragraphs and should
 be rendered with `range`.
 
+Tomorrow uses the shared `alert_digest`, `daypart_forecast`, and
+`precipitation_timing` partials.
+
 Tomorrow modules include the Hourly module fields plus:
 
 | Variable | Type | Description |
@@ -114,12 +131,87 @@ Prefer `.Modules.Dayparts` over ranging through
 `.Modules.DerivedDaypartSummaries`; it follows configured daypart order and
 falls back to sorted keys for any unmatched entries.
 
+## Daily Context
+
+The Daily template receives the same five top-level values as Tomorrow, using
+`DailyReportContext`, `Daily`, and `DailyTemplateModules`.
+
+Daily report metadata includes `.Report.Title`, `.Report.ForecastDate`,
+`.Report.ForecastDateLabel`, `.Report.ForecastDayName`,
+`.Report.GeneratedAt`, `.Report.GeneratedAtLabel`, `.Report.ValidPeriod`, and
+`.Report.Timezone`.
+
+Daily generated text uses `.GeneratedText.Summary`,
+`.GeneratedText.ForecastDiscussion`, `.GeneratedText.PrecipitationTiming`, and
+`.GeneratedText.Confidence`. Forecast discussion is a slice of paragraphs and
+should be rendered with `range`.
+
+Daily uses the shared `alert_digest`, `daypart_forecast`, and
+`precipitation_timing` partials.
+
+Daily uses template ID `daily`, generated-text schema ID `daily`, and prompt
+source `internal/reporttemplate/prompts/daily.generated_text.md`.
+
+Daily modules include the Hourly module fields plus:
+
+| Variable | Type | Description |
+| --- | --- | --- |
+| `.Modules.DerivedDailySummary` | *briefing.DerivedDailySummaryModule | Daily summary facts for the forecast date. |
+| `.Modules.DerivedDaypartSummaries` | *map[string]briefing.DerivedDaypartSummaryModule | Raw daypart summary map, when direct keyed access is needed. |
+| `.Modules.Dayparts` | []generatedtext.DailyDaypartContext | Ordered daypart summaries for deterministic template rendering. |
+| `.Modules.DailyPlanning` | *briefing.DailyPlanningModule | Planning facts for the selected local civil day. |
+
+Prefer `.Modules.Dayparts` over ranging through
+`.Modules.DerivedDaypartSummaries`; it follows configured daypart order and
+falls back to sorted keys for any unmatched entries.
+
+## Today Context
+
+The Today template receives the same five top-level values as Tomorrow, using
+`TodayReportContext`, `Today`, and `TodayTemplateModules`.
+
+Today report metadata includes `.Report.Title`, `.Report.ForecastDate`,
+`.Report.ForecastDateLabel`, `.Report.ForecastDayName`,
+`.Report.GeneratedAt`, `.Report.GeneratedAtLabel`, `.Report.ValidPeriod`, and
+`.Report.Timezone`.
+
+Today generated text uses `.GeneratedText.Summary`,
+`.GeneratedText.ForecastDiscussion`, `.GeneratedText.PrecipitationTiming`, and
+`.GeneratedText.Confidence`. Forecast discussion is a slice of paragraphs and
+should be rendered with `range`.
+
+Today uses the `today_daypart_forecast` partial so elapsed or missing dayparts
+can be omitted while Daily and Tomorrow keep their fallback row. It also uses
+the shared `alert_digest` and `precipitation_timing` partials.
+
+Today uses template ID `today`, generated-text schema ID `today`, and prompt
+source `internal/reporttemplate/prompts/today.generated_text.md`.
+
+Today modules include the Hourly module fields plus:
+
+| Variable | Type | Description |
+| --- | --- | --- |
+| `.Modules.DerivedDailySummary` | *briefing.DerivedDailySummaryModule | Daily summary facts for the forecast date. |
+| `.Modules.DerivedDaypartSummaries` | *map[string]briefing.DerivedDaypartSummaryModule | Raw daypart summary map, when direct keyed access is needed. |
+| `.Modules.Dayparts` | []generatedtext.TodayDaypartContext | Ordered daypart summaries for deterministic template rendering. |
+| `.Modules.TodayPlanning` | *briefing.TodayPlanningModule | Planning facts for the current local civil day. |
+
+Prefer `.Modules.Dayparts` over ranging through
+`.Modules.DerivedDaypartSummaries`; it follows configured daypart order and
+falls back to sorted keys for any unmatched entries.
+
 ## Modules
 
 `.Modules` exposes typed outputs from the same module pipeline used for the
 prompt data package. Module fields are pointers because missing-data policy may
 omit a stanza.
 
+Templates render from rich module values, not from the curated YAML data
+package. Some fields documented below are deterministic wording helpers for
+Markdown templates and are intentionally omitted from data packages passed to
+Scriptorium. The data package is a prompt input, while the render context is the
+template surface.
+
 | Variable | Type | Description |
 | --- | --- | --- |
 | `.Modules.Metadata` | *briefing.MetadataModule | Report metadata module output, when present. |
@@ -204,8 +296,48 @@ Common fields:
 | `.Modules.PrecipTiming.PrecipitationWindows[].MaxPopPercent` | *int | Highest precipitation probability inside the window. |
 | `.Modules.PrecipTiming.PrecipitationWindows[].MaxPopTime` | string | Friendly local time for the window maximum. |
 | `.Modules.PrecipTiming.PrecipitationWindows[].MaxPopHourLabel` | string | Friendly hour label for the window maximum. |
+| `.Modules.PrecipTiming.PrecipitationWindows[].PrecipitationType` | string | Conservatively inferred precipitation type, such as `showers and thunderstorms`. |
+| `.Modules.PrecipTiming.PrecipitationWindows[].ExpectationPhrase` | string | Probability-based sentence used by precipitation timing templates. |
 | `.Modules.PrecipTiming.ThunderMentioned` | bool | Whether thunder is mentioned in the forecast text. |
 
+### Daypart Summaries
+
+Daily, Today, and Tomorrow templates should use `.Modules.Dayparts` for
+ordered daypart rendering. Each item has `Key` and `Summary`; `Summary` is a
+rich `briefing.DerivedDaypartSummaryModule`.
+
+The shared daypart partials render from these same `.Modules.Dayparts` values.
+Edit `daypart_forecast.md.tmpl` for common Daily/Tomorrow wording, and edit
+`today_daypart_forecast.md.tmpl` for Today-specific omission behavior.
+
+Common rich daypart fields:
+
+| Variable | Type | Description |
+| --- | --- | --- |
+| `.Modules.Dayparts[].Summary.DisplayName` | string | Human-readable daypart label. |
+| `.Modules.Dayparts[].Summary.PeriodBegins` | string | Friendly local daypart start. |
+| `.Modules.Dayparts[].Summary.PeriodEnds` | string | Friendly local daypart end. |
+| `.Modules.Dayparts[].Summary.TempRangeF` | string | Rounded temperature range or single temperature. |
+| `.Modules.Dayparts[].Summary.TemperaturePhraseF` | string | Temperature phrase used for steady template wording. |
+| `.Modules.Dayparts[].Summary.TemperatureTrend` | string | Trend category such as `rising`, `falling`, `peaking`, or `steady`. |
+| `.Modules.Dayparts[].Summary.TemperatureStartPhraseF` | string | Starting temperature phrase for rising/falling wording. |
+| `.Modules.Dayparts[].Summary.TemperatureEndPhraseF` | string | Ending temperature phrase for rising/falling wording. |
+| `.Modules.Dayparts[].Summary.TemperaturePeakPhraseF` | string | Peak temperature phrase for peaking wording. |
+| `.Modules.Dayparts[].Summary.TemperatureSteadyPhraseF` | string | Steady temperature phrase. |
+| `.Modules.Dayparts[].Summary.MaxPopPercent` | *int | Highest precipitation probability in the daypart. |
+| `.Modules.Dayparts[].Summary.MaxPopTime` | string | Friendly local time for the highest precipitation probability. |
+| `.Modules.Dayparts[].Summary.MaxPopTimeLabel` | string | Clock-style label for deterministic precipitation timing text. |
+| `.Modules.Dayparts[].Summary.MentionPrecipitation` | bool | True when precipitation probability should be mentioned by the template. |
+| `.Modules.Dayparts[].Summary.DominantCondition` | string | Dominant condition text. |
+| `.Modules.Dayparts[].Summary.DominantConditionLower` | string | Lower-case condition text for inline sentences. |
+| `.Modules.Dayparts[].Summary.DominantConditionDisplay` | string | Display-case condition text for bullet starts. |
+| `.Modules.Dayparts[].Summary.NotableConditions` | []string | Notable condition labels retained for the daypart. |
+
+Template-only daypart helpers such as `TemperaturePhraseF`,
+`DominantConditionLower`, `DominantConditionDisplay`, and `MaxPopTimeLabel`
+remain available here even though they are not serialized into data-package
+YAML.
+
 ### Alert Digest
 
 | Variable | Type | Description |
@@ -218,6 +350,10 @@ Common fields:
 | `.Modules.AlertDigest.Relevant[].Event` | string | Alert event name. |
 | `.Modules.AlertDigest.Relevant[].Headline` | string | Alert headline. |
 | `.Modules.AlertDigest.Relevant[].Severity` | string | Alert severity. |
+| `.Modules.AlertDigest.Relevant[].PeriodBegins` | string | Friendly local alert applicability start. |
+| `.Modules.AlertDigest.Relevant[].PeriodEnds` | string | Friendly local alert applicability end. |
+| `.Modules.AlertDigest.Relevant[].Instruction` | string | Alert instruction text, when provided. |
+| `.Modules.AlertDigest.Relevant[].Description` | string | Alert description text, when provided. |
 
 ### SPC Outlooks And Discussion
 
@@ -234,6 +370,11 @@ Common fields:
 | `.Modules.SPCConvectiveOutlooks.Outlooks[].PeriodBegins` | string | Friendly outlook period start. |
 | `.Modules.SPCConvectiveOutlooks.Outlooks[].PeriodEnds` | string | Friendly outlook period end. |
 | `.Modules.SPCConvectiveOutlooks.Outlooks[].ImageURL` | string | Source image URL. |
+| `.Modules.SPCConvectiveOutlooks.RiskDigest` | []briefing.SPCConvectiveOutlookDigest | Curated categorical outlooks for the shared Alerts and Risk Products section. |
+| `.Modules.SPCConvectiveOutlooks.RiskDigest[].LabelText` | string | Human-readable outlook label. |
+| `.Modules.SPCConvectiveOutlooks.RiskDigest[].RiskLabel` | string | Sentence-style risk label for report rendering. |
+| `.Modules.SPCConvectiveOutlooks.RiskDigest[].PeriodBegins` | string | Friendly outlook period start. |
+| `.Modules.SPCConvectiveOutlooks.RiskDigest[].PeriodEnds` | string | Friendly outlook period end. |
 | `.Modules.SPCConvectiveDiscussion.IncludedBecause` | string | Criterion used to include discussions. |
 | `.Modules.SPCConvectiveDiscussion.Discussions` | []briefing.SPCConvectiveDiscussionRecord | Retained discussion records. |
 | `.Modules.SPCConvectiveDiscussion.Discussions[].Headline` | string | Discussion headline. |
@@ -296,6 +437,6 @@ go run ./cmd/weatherreporter --help
 git diff --check
 ```
 
-Template render tests currently exercise the hourly template through
-`internal/generatedtext/render_context_test.go` and
+Template render tests exercise the Daily, Today, Tomorrow, and Hourly
+templates through `internal/generatedtext/render_context_test.go` and
 `internal/reporttemplate/reporttemplate_test.go`.

docs/troubleshooting.md

@@ -6,7 +6,7 @@ fixes. See [CLI reference](cli.md), [Configuration reference](config.md), and
 
 ## `weather_api.base_url is required`
 
-Symptom: a generation command fails before fetching weather data.
+Symptom: a generation command fails before collecting weather data.
 
 Likely cause: no Weather API base URL is configured.
 
@@ -187,8 +187,8 @@ Relevant docs: [Operations guide](operations.md),
 
 ## Generated Text Validation Fails
 
-Symptom: Tomorrow or Hourly generation fails with generated-text decode,
-unknown-field, required-field, or multiple-JSON-values context.
+Symptom: Daily, Today, Tomorrow, or Hourly generation fails with generated-text
+decode, unknown-field, required-field, or multiple-JSON-values context.
 
 Likely cause: Scriptorium wrote structured JSON that does not match the
 GeneratedText contract for the selected report.
@@ -210,8 +210,8 @@ Relevant docs: [Operations guide](operations.md),
 
 ## Template Rendering Fails
 
-Symptom: Tomorrow or Hourly generation fails with report template parsing or
-execution context after generated text validation succeeds.
+Symptom: Daily, Today, Tomorrow, or Hourly generation fails with report template
+parsing or execution context after generated text validation succeeds.
 
 Likely cause: an embedded template references a missing context field or
 receives a value shape that does not match its typed render context.
@@ -235,16 +235,108 @@ Relevant docs: [Report Templates](templates.md),
 
 Symptom: `run morning` or `run evening` returns nonzero.
 
-Likely cause: at least one report in the batch failed.
+Likely cause: weather collection failed before planning, or at least one
+planned report failed after planning succeeded, or every report succeeded but
+the top-level batch distributor notification failed.
 
-Diagnostic: inspect stdout for the JSON summary and stderr for compact status
-lines.
+Diagnostic: if stdout contains a JSON summary, inspect each failed report item
+and the top-level `notification` object. Stderr includes one
+`batchNotification` line when batch notification is attempted, skipped, or
+fails. If no summary was emitted, inspect the command error; configuration,
+Weather API collection, or batch validation failed before any report artifacts
+were created.
 
-Safe fix: use the failed report's artifact paths from the summary, then inspect
-metadata, sources, module snapshot, and data package for that RunID.
+Safe fix: for collection failures, fix the configuration or upstream Weather
+API availability and rerun the batch. For report failures, use the failed
+report's artifact paths from the summary, then inspect metadata, sources,
+module snapshot, and data package for that RunID. For a batch notification
+failure, inspect the notification artifact path from the top-level
+`notification.path`.
 
 Relevant docs: [CLI reference](cli.md), [Operations guide](operations.md).
 
+## Batch Upload Skipped
+
+Symptom: a batch JSON summary contains
+`"notification":{"status":"skipped","reason":"one or more reports failed"}`.
+
+Likely cause: at least one planned report failed, so weatherreporter did not
+call distributor for the batch.
+
+Diagnostic: inspect the failed report items in the batch JSON summary and the
+matching stderr report lines. A skipped batch notification has no distributor
+run ID and no notification artifact path.
+
+Safe fix: fix the report-generation failure first, then rerun the batch. The
+batch upload is all-or-nothing.
+
+Relevant docs: [Operations guide](operations.md).
+
+## Batch Upload Fails
+
+Symptom: every report item in a batch summary is succeeded, but the batch
+returns nonzero and the top-level notification has `status: "failed"`.
+
+Likely cause: the distributor upload was rejected, the distributor service was
+unavailable, status polling reached a terminal distributor failure, or
+weatherreporter rejected the batch file mapping before upload.
+
+Diagnostic: inspect `notification.error`, `notification.pipelineId`,
+`notification.bundleId`, `notification.idempotencyKey`, and
+`notification.path` in stdout. Then inspect the notification artifact; it
+records included report source paths, bundle paths, upload status, distributor
+run status, status lookup error, and raw status report JSON when available.
+
+Safe fix: fix the endpoint, token, distributor pipeline, batch identity
+templates, or report path templates indicated by the error, then rerun the
+batch. Individual report artifacts from the failed batch notification remain
+available and do not need to be regenerated for diagnosis.
+
+Relevant docs: [Configuration reference](config.md),
+[Operations guide](operations.md).
+
+## Duplicate Batch Bundle Path
+
+Symptom: a batch returns nonzero with duplicate bundle path context before a
+distributor run ID is accepted.
+
+Likely cause: report-specific distributor path templates rendered the same
+bundle-relative path for two included reports in the same batch.
+
+Diagnostic: inspect the error in stdout or stderr. The validation error
+includes the duplicate bundle path plus the report IDs, RunIDs, and managed
+source paths involved.
+
+Safe fix: configure a per-report distributor path override so every report in a
+batch renders a unique path. Include values such as `{artifact_group}`,
+`{valid_start_date}`, `{batch_output_name}`, or `{run_id}` when needed.
+
+Relevant docs: [Configuration reference](config.md),
+[Operations guide](operations.md).
+
+## Distributor Source Conflict
+
+Symptom: distributor accepts or rejects an upload with conflict context for a
+source, destination, digest, or idempotency key.
+
+Likely cause: the rendered bundle ID or idempotency key does not match the
+intended producer identity. A bundle ID identifies the logical source stream;
+an idempotency key identifies a retry of the same upload request.
+
+Diagnostic: inspect the report notification artifact linked from metadata or
+the batch notification artifact linked from the top-level notification path.
+Compare the rendered pipeline ID, bundle ID, idempotency key, included source
+paths, and bundle paths with `notify.distributor.*` templates and distributor
+pipeline state.
+
+Safe fix: keep bundle ID templates stable for the source stream that should be
+updated, and keep idempotency keys stable only for retries of the same generated
+content. Do not reuse one idempotency key for different report or batch
+content.
+
+Relevant docs: [Operations guide](operations.md),
+[Distributor adapter internals](internal/distributor-adapter.md).
+
 ## Invalid Secrets Directory
 
 Symptom: config loading fails with `read secrets directory`, `secret file`, or
@@ -291,12 +383,14 @@ within the same distributor token and pipeline. By default the bundle ID is a
 stable report-stream identity and the idempotency key appends RunID.
 
 Diagnostic: inspect the failed batch JSON or stderr line for pipeline, bundle,
-and idempotency context. Compare the configured templates with the report RunID
-and report path.
+and idempotency context. For batch commands, use the top-level notification
+object rather than per-report notification fields. Compare the configured
+templates with the report RunID or batch RunID and report path.
 
-Also inspect the notification artifact linked from metadata. It records the
-rendered pipeline ID, bundle ID, idempotency key, upload result, distributor run
-status, status error, and raw run report JSON when available.
+Also inspect the notification artifact linked from metadata or from the
+top-level batch notification path. It records the rendered pipeline ID, bundle
+ID, idempotency key, upload result, distributor run status, status error, and
+raw run report JSON when available.
 
 Safe fix: keep idempotency templates stable for retries of the same generated
 report, but do not reuse the same rendered key for different generated report
@@ -314,9 +408,10 @@ Likely cause: the distributor endpoint rejected the token, pipeline ID, bundle
 ID, idempotency key, source file, or one of the rendered bundle paths.
 
 Diagnostic: inspect stdout JSON or stderr status lines for
-`notificationError`. Confirm `notify.distributor.endpoint`,
+`notificationError` or the top-level batch notification `error`. Confirm
+`notify.distributor.endpoint`,
 `notify.distributor.pipeline_id_template`,
-`notify.distributor.report_path_templates`, and token configuration. Token
+report-specific distributor paths, and token configuration. Token
 values are redacted from weatherreporter errors.
 
 If the upload was accepted but destination output did not change, inspect the
@@ -341,8 +436,8 @@ Likely cause: the configured distributor endpoint is unreachable, slow, or
 temporarily unavailable.
 
 Diagnostic: check network access from the weatherreporter host to
-`notify.distributor.endpoint`. For batch runs, inspect which reports have
-`notificationStatus: "failed"`.
+`notify.distributor.endpoint`. For batch runs, inspect the top-level
+notification object and the artifact linked by `notification.path`.
 
 Safe fix: restore distributor service availability and rerun the affected
 report or batch. Stable idempotency keys make retrying the same generated report

examples/config.yml

@@ -1,5 +1,5 @@
 weather_api:
-  base_url: https://weather.api.rakestrawhome.com/
+  base_url: https://weather.api.example.com/
   timeout: 15s
   precision: 1
   units: us
@@ -24,8 +24,11 @@ notify:
     pipeline_id_template: "weatherreporter.{report_id}"
     bundle_id_template: "weatherreporter.{location_id}.{report_id}"
     idempotency_key_template: "{bundle_id}.{run_id}"
-    report_path_templates:
-      - "{valid_start_date}/{artifact_group}/{valid_start_date}-{artifact_group}-{run_id}.md"
+    batch:
+      enabled: true
+      pipeline_id_template: "weatherreporter"
+      bundle_id_template: "weatherreporter.{location_id}.{batch}"
+      idempotency_key_template: "{bundle_id}.{batch_run_id}"
 
 missing_source:
   default: warn
@@ -69,6 +72,29 @@ recent_change:
 
 reports:
   daily:
+    distributor:
+      path_templates:
+        - "daily/{valid_start_date}/{run_id}.md"
+        - "daily/{valid_start_date}/index.md"
+    deterministic_modules:
+      - metadata
+      - current_conditions
+      - narrative_forecast
+      - derived_daily_summary
+      - derived_daypart_summaries
+      - precip_timing
+      - alert_digest
+      - spc_convective_outlooks
+      - id: area_forecast_discussion
+        options:
+          sections:
+            - long_term
+      - spc_convective_discussion
+      - weather_story
+      - outdoor_windows
+      - daily_planning
+      - hourly_forecast
+  today:
     deterministic_modules:
       - metadata
       - current_conditions
@@ -89,6 +115,7 @@ reports:
       - weather_story
       - outdoor_windows
       - hourly_forecast
+      - today_planning
   hourly:
     deterministic_modules:
       - metadata

internal/adapters/scriptorium/runner.go

@@ -140,61 +140,57 @@ func (r Runner) Render(ctx context.Context, req RenderRequest) (*RenderResult, e
 }
 
 func (r Runner) Run(ctx context.Context, req RunRequest) (*RunResult, error) {
-	if req.PromptID == "" {
-		return nil, fmt.Errorf("prompt id is required")
-	}
-	if req.DataPackagePath == "" {
-		return nil, fmt.Errorf("data package path is required")
-	}
-	if req.OutputPath == "" {
-		return nil, fmt.Errorf("output path is required")
-	}
-	execution, err := r.execute(ctx, r.runArgs(req))
-	if err != nil {
-		return nil, fmt.Errorf("run scriptorium: %w", err)
-	}
-	result := &RunResult{
-		Command:         execution.argv(),
-		Stdout:          string(execution.result.Stdout),
-		Stderr:          string(execution.result.Stderr),
-		StdoutTruncated: execution.result.StdoutTruncated,
-		StderrTruncated: execution.result.StderrTruncated,
-		ExitCode:        execution.result.ExitCode,
+	result, err := r.executeRun(ctx, outputRunRequest{
+		PromptID:        req.PromptID,
+		DataPackagePath: req.DataPackagePath,
 		OutputPath:      req.OutputPath,
+	}, "run scriptorium", "scriptorium run")
+	if err != nil {
+		if result == nil {
+			return nil, err
 		}
-	if execution.result.ExitCode != 0 {
-		return result, fmt.Errorf("scriptorium run exited with code %d: %s", execution.result.ExitCode, result.Stderr)
+		return result.runResult(), err
 	}
-	return result, nil
+	return result.runResult(), nil
 }
 
 func (r Runner) StructuredRun(ctx context.Context, req StructuredRunRequest) (*StructuredRunResult, error) {
-	if req.PromptID == "" {
-		return nil, fmt.Errorf("prompt id is required")
-	}
-	if req.DataPackagePath == "" {
-		return nil, fmt.Errorf("data package path is required")
-	}
-	if req.OutputPath == "" {
-		return nil, fmt.Errorf("output path is required")
-	}
-	execution, err := r.execute(ctx, r.structuredRunArgs(req))
-	if err != nil {
-		return nil, fmt.Errorf("run scriptorium structured output: %w", err)
-	}
-	result := &StructuredRunResult{
-		Command:         execution.argv(),
-		Stdout:          string(execution.result.Stdout),
-		Stderr:          string(execution.result.Stderr),
-		StdoutTruncated: execution.result.StdoutTruncated,
-		StderrTruncated: execution.result.StderrTruncated,
-		ExitCode:        execution.result.ExitCode,
+	result, err := r.executeRun(ctx, outputRunRequest{
+		PromptID:        req.PromptID,
+		DataPackagePath: req.DataPackagePath,
 		OutputPath:      req.OutputPath,
+	}, "run scriptorium structured output", "scriptorium structured run")
+	if err != nil {
+		if result == nil {
+			return nil, err
 		}
-	if execution.result.ExitCode != 0 {
-		return result, fmt.Errorf("scriptorium structured run exited with code %d: %s", execution.result.ExitCode, result.Stderr)
+		return result.structuredRunResult(), err
+	}
+	return result.structuredRunResult(), nil
+}
+
+func (result outputRunResult) runResult() *RunResult {
+	return &RunResult{
+		Command:         result.Command,
+		Stdout:          result.Stdout,
+		Stderr:          result.Stderr,
+		StdoutTruncated: result.StdoutTruncated,
+		StderrTruncated: result.StderrTruncated,
+		ExitCode:        result.ExitCode,
+		OutputPath:      result.OutputPath,
+	}
+}
+
+func (result outputRunResult) structuredRunResult() *StructuredRunResult {
+	return &StructuredRunResult{
+		Command:         result.Command,
+		Stdout:          result.Stdout,
+		Stderr:          result.Stderr,
+		StdoutTruncated: result.StdoutTruncated,
+		StderrTruncated: result.StderrTruncated,
+		ExitCode:        result.ExitCode,
+		OutputPath:      result.OutputPath,
 	}
-	return result, nil
 }
 
 type execution struct {
@@ -203,6 +199,55 @@ type execution struct {
 	result CommandResult
 }
 
+type outputRunRequest struct {
+	PromptID        string
+	DataPackagePath string
+	OutputPath      string
+}
+
+type outputRunResult struct {
+	Command         []string
+	Stdout          string
+	Stderr          string
+	StdoutTruncated bool
+	StderrTruncated bool
+	ExitCode        int
+	OutputPath      string
+}
+
+func (r Runner) executeRun(ctx context.Context, req outputRunRequest, executeContext string, exitContext string) (*outputRunResult, error) {
+	if req.PromptID == "" {
+		return nil, fmt.Errorf("prompt id is required")
+	}
+	if req.DataPackagePath == "" {
+		return nil, fmt.Errorf("data package path is required")
+	}
+	if req.OutputPath == "" {
+		return nil, fmt.Errorf("output path is required")
+	}
+	execution, err := r.execute(ctx, r.runArgs(RunRequest{
+		PromptID:        req.PromptID,
+		DataPackagePath: req.DataPackagePath,
+		OutputPath:      req.OutputPath,
+	}))
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", executeContext, err)
+	}
+	result := &outputRunResult{
+		Command:         execution.argv(),
+		Stdout:          string(execution.result.Stdout),
+		Stderr:          string(execution.result.Stderr),
+		StdoutTruncated: execution.result.StdoutTruncated,
+		StderrTruncated: execution.result.StderrTruncated,
+		ExitCode:        execution.result.ExitCode,
+		OutputPath:      req.OutputPath,
+	}
+	if execution.result.ExitCode != 0 {
+		return result, fmt.Errorf("%s exited with code %d: %s", exitContext, execution.result.ExitCode, result.Stderr)
+	}
+	return result, nil
+}
+
 func (r Runner) execute(ctx context.Context, args []string) (execution, error) {
 	binary := r.Binary
 	if binary == "" {
@@ -257,14 +302,6 @@ func (r Runner) runArgs(req RunRequest) []string {
 	return args
 }
 
-func (r Runner) structuredRunArgs(req StructuredRunRequest) []string {
-	return r.runArgs(RunRequest{
-		PromptID:        req.PromptID,
-		DataPackagePath: req.DataPackagePath,
-		OutputPath:      req.OutputPath,
-	})
-}
-
 type limitedBuffer struct {
 	data      []byte
 	limit     int

internal/adapters/scriptorium/runner_test.go

@@ -2,6 +2,7 @@ package scriptorium
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -19,7 +20,7 @@ func TestRenderConstructsCommand(t *testing.T) {
 	}
 
 	result, err := runner.Render(context.Background(), RenderRequest{
-		PromptID:        "weather.daily_report",
+		PromptID:        "weather.markdown_report",
 		DataPackagePath: "/tmp/data_package.yaml",
 	})
 	if err != nil {
@@ -30,7 +31,7 @@ func TestRenderConstructsCommand(t *testing.T) {
 		"render",
 		"--config", "/etc/scriptorium.yml",
 		"--profile", "weather",
-		"--prompt", "weather.daily_report",
+		"--prompt", "weather.markdown_report",
 		"--input", "data_package=/tmp/data_package.yaml",
 		"--format", "json",
 	}
@@ -56,7 +57,7 @@ func TestRenderReturnsResultForNonzeroExit(t *testing.T) {
 	}
 
 	result, err := runner.Render(context.Background(), RenderRequest{
-		PromptID:        "weather.daily_report",
+		PromptID:        "weather.markdown_report",
 		DataPackagePath: "/tmp/data_package.yaml",
 	})
 	if err == nil {
@@ -84,7 +85,7 @@ func TestRunConstructsCommand(t *testing.T) {
 	}
 
 	result, err := runner.Run(context.Background(), RunRequest{
-		PromptID:        "weather.daily_report",
+		PromptID:        "weather.markdown_report",
 		DataPackagePath: "/tmp/data_package.yaml",
 		OutputPath:      "/tmp/daily.md",
 	})
@@ -96,7 +97,7 @@ func TestRunConstructsCommand(t *testing.T) {
 		"run",
 		"--config", "/etc/scriptorium.yml",
 		"--profile", "weather",
-		"--prompt", "weather.daily_report",
+		"--prompt", "weather.markdown_report",
 		"--input", "data_package=/tmp/data_package.yaml",
 		"--out", "/tmp/daily.md",
 	}
@@ -129,7 +130,7 @@ func TestRunReturnsResultForValidationExit(t *testing.T) {
 	}
 
 	result, err := runner.Run(context.Background(), RunRequest{
-		PromptID:        "weather.daily_report",
+		PromptID:        "weather.markdown_report",
 		DataPackagePath: "/tmp/data_package.yaml",
 		OutputPath:      "/tmp/daily.md",
 	})
@@ -163,8 +164,8 @@ func TestStructuredRunConstructsCommandWithoutSchemaFlags(t *testing.T) {
 
 	result, err := runner.StructuredRun(context.Background(), StructuredRunRequest{
 		PromptID:        "weather.hourly_generated_text",
-		DataPackagePath: "/tmp/hourly.data_package.yaml",
-		OutputPath:      "/tmp/hourly.generated_text.raw.json",
+		DataPackagePath: "/tmp/data_package.hourly.yaml",
+		OutputPath:      "/tmp/generated_text_raw.hourly.json",
 	})
 	if err != nil {
 		t.Fatalf("StructuredRun() error = %v", err)
@@ -175,8 +176,8 @@ func TestStructuredRunConstructsCommandWithoutSchemaFlags(t *testing.T) {
 		"--config", "/etc/scriptorium.yml",
 		"--profile", "weather",
 		"--prompt", "weather.hourly_generated_text",
-		"--input", "data_package=/tmp/hourly.data_package.yaml",
-		"--out", "/tmp/hourly.generated_text.raw.json",
+		"--input", "data_package=/tmp/data_package.hourly.yaml",
+		"--out", "/tmp/generated_text_raw.hourly.json",
 	}
 	if commands.name != "/usr/local/bin/scriptorium" {
 		t.Fatalf("command name = %q, want custom binary", commands.name)
@@ -198,7 +199,7 @@ func TestStructuredRunConstructsCommandWithoutSchemaFlags(t *testing.T) {
 	if result.Stdout != `{"summary":"ok"}` || result.Stderr != "wrote generated text" || !result.StdoutTruncated {
 		t.Fatalf("result = %#v, want captured output and truncation flags", result)
 	}
-	if result.OutputPath != "/tmp/hourly.generated_text.raw.json" {
+	if result.OutputPath != "/tmp/generated_text_raw.hourly.json" {
 		t.Fatalf("OutputPath = %q, want generated text raw path", result.OutputPath)
 	}
 }
@@ -216,8 +217,8 @@ func TestStructuredRunReturnsResultForNonzeroExit(t *testing.T) {
 
 	result, err := runner.StructuredRun(context.Background(), StructuredRunRequest{
 		PromptID:        "weather.hourly_generated_text",
-		DataPackagePath: "/tmp/hourly.data_package.yaml",
-		OutputPath:      "/tmp/hourly.generated_text.raw.json",
+		DataPackagePath: "/tmp/data_package.hourly.yaml",
+		OutputPath:      "/tmp/generated_text_raw.hourly.json",
 	})
 	if err == nil {
 		t.Fatal("StructuredRun() error = nil, want nonzero exit error")
@@ -228,7 +229,7 @@ func TestStructuredRunReturnsResultForNonzeroExit(t *testing.T) {
 	if result.ExitCode != 3 {
 		t.Fatalf("ExitCode = %d, want 3", result.ExitCode)
 	}
-	if result.Stdout != `{"summary":"partial"}` || result.OutputPath != "/tmp/hourly.generated_text.raw.json" {
+	if result.Stdout != `{"summary":"partial"}` || result.OutputPath != "/tmp/generated_text_raw.hourly.json" {
 		t.Fatalf("result = %#v, want captured result fields", result)
 	}
 	if !strings.Contains(err.Error(), "structured output failed") {
@@ -236,56 +237,284 @@ func TestStructuredRunReturnsResultForNonzeroExit(t *testing.T) {
 	}
 }
 
-func TestStructuredRunValidatesRequiredFieldsBeforeExecution(t *testing.T) {
+func TestOutputRunsPreserveCapturedResultFields(t *testing.T) {
+	type commonResult struct {
+		Command         []string
+		Stdout          string
+		Stderr          string
+		StdoutTruncated bool
+		StderrTruncated bool
+		ExitCode        int
+		OutputPath      string
+	}
 	tests := []struct {
 		name string
-		req  StructuredRunRequest
+		run  func(Runner) (*commonResult, error)
+	}{
+		{
+			name: "Run",
+			run: func(runner Runner) (*commonResult, error) {
+				result, err := runner.Run(context.Background(), RunRequest{
+					PromptID:        "weather.markdown_report",
+					DataPackagePath: "/tmp/data_package.yaml",
+					OutputPath:      "/tmp/report.md",
+				})
+				if result == nil {
+					return nil, err
+				}
+				return &commonResult{
+					Command:         result.Command,
+					Stdout:          result.Stdout,
+					Stderr:          result.Stderr,
+					StdoutTruncated: result.StdoutTruncated,
+					StderrTruncated: result.StderrTruncated,
+					ExitCode:        result.ExitCode,
+					OutputPath:      result.OutputPath,
+				}, err
+			},
+		},
+		{
+			name: "StructuredRun",
+			run: func(runner Runner) (*commonResult, error) {
+				result, err := runner.StructuredRun(context.Background(), StructuredRunRequest{
+					PromptID:        "weather.markdown_report",
+					DataPackagePath: "/tmp/data_package.yaml",
+					OutputPath:      "/tmp/report.md",
+				})
+				if result == nil {
+					return nil, err
+				}
+				return &commonResult{
+					Command:         result.Command,
+					Stdout:          result.Stdout,
+					Stderr:          result.Stderr,
+					StdoutTruncated: result.StdoutTruncated,
+					StderrTruncated: result.StderrTruncated,
+					ExitCode:        result.ExitCode,
+					OutputPath:      result.OutputPath,
+				}, err
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			commands := &fakeCommands{result: CommandResult{
+				Stdout:          []byte("captured stdout"),
+				Stderr:          []byte("captured stderr"),
+				StdoutTruncated: true,
+				StderrTruncated: true,
+			}}
+			runner := Runner{
+				Binary:     "/usr/local/bin/scriptorium",
+				ConfigPath: "/etc/scriptorium.yml",
+				Profile:    "weather",
+				Timeout:    15 * time.Second,
+				Commands:   commands,
+			}
+
+			result, err := test.run(runner)
+			if err != nil {
+				t.Fatalf("%s error = %v", test.name, err)
+			}
+			wantArgs := []string{
+				"run",
+				"--config", "/etc/scriptorium.yml",
+				"--profile", "weather",
+				"--prompt", "weather.markdown_report",
+				"--input", "data_package=/tmp/data_package.yaml",
+				"--out", "/tmp/report.md",
+			}
+			if !reflect.DeepEqual(commands.args, wantArgs) {
+				t.Fatalf("args = %#v, want %#v", commands.args, wantArgs)
+			}
+			if commands.timeout != 15*time.Second {
+				t.Fatalf("timeout = %s, want 15s", commands.timeout)
+			}
+			if !reflect.DeepEqual(result.Command, append([]string{"/usr/local/bin/scriptorium"}, wantArgs...)) {
+				t.Fatalf("Command = %#v, want full argv", result.Command)
+			}
+			if result.Stdout != "captured stdout" || result.Stderr != "captured stderr" {
+				t.Fatalf("captured output = %q/%q, want stdout/stderr", result.Stdout, result.Stderr)
+			}
+			if !result.StdoutTruncated || !result.StderrTruncated {
+				t.Fatalf("truncation flags = %t/%t, want both true", result.StdoutTruncated, result.StderrTruncated)
+			}
+			if result.ExitCode != 0 || result.OutputPath != "/tmp/report.md" {
+				t.Fatalf("result = %#v, want exit 0 and output path", result)
+			}
+		})
+	}
+}
+
+func TestOutputRunsReturnCapturedResultForNonzeroExit(t *testing.T) {
+	type commonResult struct {
+		Stdout          string
+		Stderr          string
+		StderrTruncated bool
+		ExitCode        int
+		OutputPath      string
+	}
+	tests := []struct {
+		name    string
+		run     func(Runner) (*commonResult, error)
+		wantErr string
+	}{
+		{
+			name: "Run",
+			run: func(runner Runner) (*commonResult, error) {
+				result, err := runner.Run(context.Background(), RunRequest{
+					PromptID:        "weather.markdown_report",
+					DataPackagePath: "/tmp/data_package.yaml",
+					OutputPath:      "/tmp/report.md",
+				})
+				if result == nil {
+					return nil, err
+				}
+				return &commonResult{
+					Stdout:          result.Stdout,
+					Stderr:          result.Stderr,
+					StderrTruncated: result.StderrTruncated,
+					ExitCode:        result.ExitCode,
+					OutputPath:      result.OutputPath,
+				}, err
+			},
+			wantErr: "scriptorium run exited with code 7: captured stderr",
+		},
+		{
+			name: "StructuredRun",
+			run: func(runner Runner) (*commonResult, error) {
+				result, err := runner.StructuredRun(context.Background(), StructuredRunRequest{
+					PromptID:        "weather.markdown_report",
+					DataPackagePath: "/tmp/data_package.yaml",
+					OutputPath:      "/tmp/report.md",
+				})
+				if result == nil {
+					return nil, err
+				}
+				return &commonResult{
+					Stdout:          result.Stdout,
+					Stderr:          result.Stderr,
+					StderrTruncated: result.StderrTruncated,
+					ExitCode:        result.ExitCode,
+					OutputPath:      result.OutputPath,
+				}, err
+			},
+			wantErr: "scriptorium structured run exited with code 7: captured stderr",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			runner := Runner{
+				Commands: &fakeCommands{result: CommandResult{
+					Stdout:          []byte("captured stdout"),
+					Stderr:          []byte("captured stderr"),
+					StderrTruncated: true,
+					ExitCode:        7,
+				}},
+			}
+
+			result, err := test.run(runner)
+			if err == nil {
+				t.Fatalf("%s error = nil, want nonzero exit error", test.name)
+			}
+			if result == nil {
+				t.Fatalf("%s result = nil, want captured result", test.name)
+			}
+			if err.Error() != test.wantErr {
+				t.Fatalf("%s error = %q, want %q", test.name, err.Error(), test.wantErr)
+			}
+			if result.Stdout != "captured stdout" || result.Stderr != "captured stderr" || !result.StderrTruncated {
+				t.Fatalf("captured result = %#v, want stdout/stderr/truncation", result)
+			}
+			if result.ExitCode != 7 || result.OutputPath != "/tmp/report.md" {
+				t.Fatalf("result = %#v, want exit 7 and output path", result)
+			}
+		})
+	}
+}
+
+func TestOutputRunsValidateRequiredFieldsBeforeExecution(t *testing.T) {
+	tests := []struct {
+		name string
+		run  func(Runner, string, string, string) error
+	}{
+		{
+			name: "Run",
+			run: func(runner Runner, promptID string, dataPackagePath string, outputPath string) error {
+				result, err := runner.Run(context.Background(), RunRequest{
+					PromptID:        promptID,
+					DataPackagePath: dataPackagePath,
+					OutputPath:      outputPath,
+				})
+				if result != nil {
+					return fmt.Errorf("result = %#v, want nil", result)
+				}
+				return err
+			},
+		},
+		{
+			name: "StructuredRun",
+			run: func(runner Runner, promptID string, dataPackagePath string, outputPath string) error {
+				result, err := runner.StructuredRun(context.Background(), StructuredRunRequest{
+					PromptID:        promptID,
+					DataPackagePath: dataPackagePath,
+					OutputPath:      outputPath,
+				})
+				if result != nil {
+					return fmt.Errorf("result = %#v, want nil", result)
+				}
+				return err
+			},
+		},
+	}
+	cases := []struct {
+		name            string
+		promptID        string
+		dataPackagePath string
+		outputPath      string
 		want            string
 	}{
 		{
 			name:            "prompt id",
-			req: StructuredRunRequest{
-				DataPackagePath: "/tmp/hourly.data_package.yaml",
-				OutputPath:      "/tmp/hourly.generated_text.raw.json",
-			},
+			dataPackagePath: "/tmp/data_package.yaml",
+			outputPath:      "/tmp/report.md",
 			want:            "prompt id is required",
 		},
 		{
 			name:       "data package path",
-			req: StructuredRunRequest{
-				PromptID:   "weather.hourly_generated_text",
-				OutputPath: "/tmp/hourly.generated_text.raw.json",
-			},
+			promptID:   "weather.markdown_report",
+			outputPath: "/tmp/report.md",
 			want:       "data package path is required",
 		},
 		{
 			name:            "output path",
-			req: StructuredRunRequest{
-				PromptID:        "weather.hourly_generated_text",
-				DataPackagePath: "/tmp/hourly.data_package.yaml",
-			},
+			promptID:        "weather.markdown_report",
+			dataPackagePath: "/tmp/data_package.yaml",
 			want:            "output path is required",
 		},
 	}
+
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
+			for _, tc := range cases {
+				t.Run(tc.name, func(t *testing.T) {
 					commands := &fakeCommands{}
-			runner := Runner{Commands: commands}
-			result, err := runner.StructuredRun(context.Background(), test.req)
+					err := test.run(Runner{Commands: commands}, tc.promptID, tc.dataPackagePath, tc.outputPath)
 					if err == nil {
-				t.Fatal("StructuredRun() error = nil, want validation error")
+						t.Fatalf("%s error = nil, want validation error", test.name)
 					}
-			if result != nil {
-				t.Fatalf("StructuredRun() result = %#v, want nil", result)
-			}
-			if !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("StructuredRun() error = %v, want %q", err, test.want)
+					if !strings.Contains(err.Error(), tc.want) {
+						t.Fatalf("%s error = %v, want %q", test.name, err, tc.want)
 					}
 					if commands.calls != 0 {
 						t.Fatalf("commands calls = %d, want no subprocess execution", commands.calls)
 					}
 				})
 			}
+		})
+	}
 }
 
 type fakeCommands struct {

internal/adapters/weatherapi/client.go

@@ -130,18 +130,32 @@ type bundleBuilder struct {
 	fetchedAt time.Time
 }
 
+type sourceRequest struct {
+	name           string
+	endpoint       string
+	query          queryOptions
+	missingMessage string
+	required       bool
+	decodeLabel    string
+}
+
+type fetchedSource struct {
+	raw    json.RawMessage
+	source weatherdata.Source
+}
+
 func (b *bundleBuilder) fetchObservation(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, "observations", "/observations", queryOptions{precision: true})
-	if err != nil {
+	var observation weatherdata.Observation
+	fetched, ok, err := b.fetchDecodedSource(ctx, sourceRequest{
+		name:           "observations",
+		endpoint:       "/observations",
+		query:          queryOptions{precision: true},
+		missingMessage: "observation data is missing",
+	}, &observation)
+	if err != nil || !ok {
 		return err
 	}
-	if raw == nil {
-		return b.handleMissing(&source, "observation data is missing", false)
-	}
-	var observation weatherdata.Observation
-	if err := decodeSource(raw, &observation); err != nil {
-		return b.handleMalformed(&source, err, false)
-	}
+	source := fetched.source
 	source.IssuedAt = &observation.Timestamp
 	b.bundle.Observation = &observation
 	b.addSource(source)
@@ -149,34 +163,36 @@ func (b *bundleBuilder) fetchObservation(ctx context.Context) error {
 }
 
 func (b *bundleBuilder) fetchCurrent(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, "current", "/conditions/current", queryOptions{precision: true})
-	if err != nil {
+	var current weatherdata.Current
+	fetched, ok, err := b.fetchDecodedSource(ctx, sourceRequest{
+		name:           "current",
+		endpoint:       "/conditions/current",
+		query:          queryOptions{precision: true},
+		missingMessage: "current conditions data is missing",
+	}, &current)
+	if err != nil || !ok {
 		return err
 	}
-	if raw == nil {
-		return b.handleMissing(&source, "current conditions data is missing", false)
-	}
-	var current weatherdata.Current
-	if err := decodeSource(raw, &current); err != nil {
-		return b.handleMalformed(&source, err, false)
-	}
+	source := fetched.source
 	b.bundle.Current = &current
 	b.addSource(source)
 	return nil
 }
 
 func (b *bundleBuilder) fetchHourly(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, "hourly", "/forecast/hourly", queryOptions{precision: true, timezone: true})
-	if err != nil {
+	var hourly weatherdata.ForecastRun
+	fetched, ok, err := b.fetchDecodedSource(ctx, sourceRequest{
+		name:           "hourly",
+		endpoint:       "/forecast/hourly",
+		query:          queryOptions{precision: true, timezone: true},
+		missingMessage: "hourly forecast data is missing",
+		required:       true,
+		decodeLabel:    "hourly forecast",
+	}, &hourly)
+	if err != nil || !ok {
 		return err
 	}
-	if raw == nil {
-		return b.handleMissing(&source, "hourly forecast data is missing", true)
-	}
-	var hourly weatherdata.ForecastRun
-	if err := decodeSource(raw, &hourly); err != nil {
-		return fmt.Errorf("decode hourly forecast from %s: %w", source.Endpoint, err)
-	}
+	source := fetched.source
 	if len(hourly.Periods) == 0 {
 		return fmt.Errorf("hourly forecast from %s contains no periods", source.Endpoint)
 	}
@@ -188,17 +204,17 @@ func (b *bundleBuilder) fetchHourly(ctx context.Context) error {
 }
 
 func (b *bundleBuilder) fetchNarrative(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, "narrative", "/forecast/narrative", queryOptions{precision: true, timezone: true})
-	if err != nil {
+	var narrative weatherdata.ForecastRun
+	fetched, ok, err := b.fetchDecodedSource(ctx, sourceRequest{
+		name:           "narrative",
+		endpoint:       "/forecast/narrative",
+		query:          queryOptions{precision: true, timezone: true},
+		missingMessage: "narrative forecast data is missing",
+	}, &narrative)
+	if err != nil || !ok {
 		return err
 	}
-	if raw == nil {
-		return b.handleMissing(&source, "narrative forecast data is missing", false)
-	}
-	var narrative weatherdata.ForecastRun
-	if err := decodeSource(raw, &narrative); err != nil {
-		return b.handleMalformed(&source, err, false)
-	}
+	source := fetched.source
 	source.IssuedAt = &narrative.IssuedAt
 	source.UpdatedAt = narrative.UpdatedAt
 	b.bundle.Narrative = &narrative
@@ -221,7 +237,7 @@ func (b *bundleBuilder) fetchAlerts(ctx context.Context) error {
 	}
 	var alerts weatherdata.AlertRun
 	if err := decodeSource(raw, &alerts); err != nil {
-		return b.handleMalformed(&source, err, false)
+		return b.handleMalformed(&source, err, sourceRequest{name: "alerts"})
 	}
 	alerts.Raw = append(json.RawMessage(nil), raw...)
 	if alerts.AsOf != nil {
@@ -233,17 +249,17 @@ func (b *bundleBuilder) fetchAlerts(ctx context.Context) error {
 }
 
 func (b *bundleBuilder) fetchDiscussion(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, "discussion", "/discussion", queryOptions{timezone: true})
-	if err != nil {
+	var discussion weatherdata.Discussion
+	fetched, ok, err := b.fetchDecodedSource(ctx, sourceRequest{
+		name:           "discussion",
+		endpoint:       "/discussion",
+		query:          queryOptions{timezone: true},
+		missingMessage: "forecast discussion data is missing",
+	}, &discussion)
+	if err != nil || !ok {
 		return err
 	}
-	if raw == nil {
-		return b.handleMissing(&source, "forecast discussion data is missing", false)
-	}
-	var discussion weatherdata.Discussion
-	if err := decodeSource(raw, &discussion); err != nil {
-		return b.handleMalformed(&source, err, false)
-	}
+	source := fetched.source
 	source.IssuedAt = &discussion.IssuedAt
 	source.UpdatedAt = discussion.UpdatedAt
 	b.bundle.Discussion = &discussion
@@ -252,17 +268,17 @@ func (b *bundleBuilder) fetchDiscussion(ctx context.Context) error {
 }
 
 func (b *bundleBuilder) fetchWeatherStory(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, "weather_story", "/weatherstories/latest", queryOptions{omitUnits: true})
-	if err != nil {
+	var story weatherdata.WeatherStory
+	fetched, ok, err := b.fetchDecodedSource(ctx, sourceRequest{
+		name:           "weather_story",
+		endpoint:       "/weatherstories/latest",
+		query:          queryOptions{omitUnits: true},
+		missingMessage: "NWS weather story data is missing",
+	}, &story)
+	if err != nil || !ok {
 		return err
 	}
-	if raw == nil {
-		return b.handleMissing(&source, "NWS weather story data is missing", false)
-	}
-	var story weatherdata.WeatherStory
-	if err := decodeSource(raw, &story); err != nil {
-		return b.handleMalformed(&source, err, false)
-	}
+	source := fetched.source
 	if !story.StartTime.IsZero() {
 		source.IssuedAt = &story.StartTime
 	}
@@ -273,17 +289,17 @@ func (b *bundleBuilder) fetchWeatherStory(ctx context.Context) error {
 }
 
 func (b *bundleBuilder) fetchSPCConvectiveOutlooks(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, sourceSPCConvectiveOutlooks, convectiveOutlooksEndpoint, queryOptions{timezone: true, omitUnits: true})
-	if err != nil {
+	var run weatherdata.ConvectiveOutlookRun
+	fetched, ok, err := b.fetchDecodedSource(ctx, sourceRequest{
+		name:           sourceSPCConvectiveOutlooks,
+		endpoint:       convectiveOutlooksEndpoint,
+		query:          queryOptions{timezone: true, omitUnits: true},
+		missingMessage: "SPC convective outlook data is missing",
+	}, &run)
+	if err != nil || !ok {
 		return err
 	}
-	if raw == nil {
-		return b.handleMissing(&source, "SPC convective outlook data is missing", false)
-	}
-	var run weatherdata.ConvectiveOutlookRun
-	if err := decodeSource(raw, &run); err != nil {
-		return b.handleMalformed(&source, err, false)
-	}
+	source := fetched.source
 	if run.IssuedAt != nil {
 		source.IssuedAt = run.IssuedAt
 	} else {
@@ -295,6 +311,28 @@ func (b *bundleBuilder) fetchSPCConvectiveOutlooks(ctx context.Context) error {
 	return nil
 }
 
+func (b *bundleBuilder) fetchDecodedSource(ctx context.Context, request sourceRequest, target any) (fetchedSource, bool, error) {
+	fetched, ok, err := b.fetchSource(ctx, request)
+	if err != nil || !ok {
+		return fetchedSource{}, false, err
+	}
+	if err := decodeSource(fetched.raw, target); err != nil {
+		return fetchedSource{}, false, b.handleMalformed(&fetched.source, err, request)
+	}
+	return fetched, true, nil
+}
+
+func (b *bundleBuilder) fetchSource(ctx context.Context, request sourceRequest) (fetchedSource, bool, error) {
+	raw, source, err := b.client.fetch(ctx, request.name, request.endpoint, request.query)
+	if err != nil {
+		return fetchedSource{}, false, err
+	}
+	if raw == nil {
+		return fetchedSource{}, false, b.handleMissing(&source, request.missingMessage, request.required)
+	}
+	return fetchedSource{raw: raw, source: source}, true, nil
+}
+
 func (b *bundleBuilder) handleMissing(source *weatherdata.Source, message string, required bool) error {
 	source.Missing = true
 	if required {
@@ -303,9 +341,13 @@ func (b *bundleBuilder) handleMissing(source *weatherdata.Source, message string
 	return b.applyMissingPolicy(source, "missing_source", message)
 }
 
-func (b *bundleBuilder) handleMalformed(source *weatherdata.Source, err error, required bool) error {
-	if required {
-		return fmt.Errorf("decode %s from %s: %w", source.Name, source.Endpoint, err)
+func (b *bundleBuilder) handleMalformed(source *weatherdata.Source, err error, request sourceRequest) error {
+	if request.required {
+		label := request.name
+		if request.decodeLabel != "" {
+			label = request.decodeLabel
+		}
+		return fmt.Errorf("decode %s from %s: %w", label, source.Endpoint, err)
 	}
 	source.Missing = true
 	return b.applyMissingPolicy(source, "malformed_source", fmt.Sprintf("malformed %s data: %v", source.Name, err))

internal/adapters/weatherapi/client_test.go

@@ -70,6 +70,24 @@ func TestFetchBundleFromFixtures(t *testing.T) {
 	if len(bundle.Warnings) != 0 {
 		t.Fatalf("Warnings length = %d, want no warnings", len(bundle.Warnings))
 	}
+	wantPaths := []string{
+		"/observations",
+		"/conditions/current",
+		"/forecast/hourly",
+		"/forecast/narrative",
+		"/alerts/active",
+		"/discussion",
+		"/weatherstories/latest",
+		convectiveOutlooksEndpoint,
+	}
+	if len(requested) != len(wantPaths) {
+		t.Fatalf("requested paths = %v, want %d source endpoints", requested, len(wantPaths))
+	}
+	for _, want := range wantPaths {
+		if !containsPath(requested, want) {
+			t.Fatalf("requested paths = %v, want %s", requested, want)
+		}
+	}
 	if !containsPath(requested, "/forecast/hourly") || containsPath(requested, "/forecast/hourly/today") {
 		t.Fatalf("requested paths = %v, want full hourly endpoint only", requested)
 	}

internal/app/app.go

@@ -10,9 +10,9 @@ import (
 
 	distributoradapter "gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/distributor"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/scriptorium"
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/weatherapi"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/changes"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/collect"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/facts"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/fileutil"
@@ -21,7 +21,6 @@ import (
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/reporttemplate"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/state"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
@@ -30,19 +29,20 @@ import (
 type ReportKind string
 
 const (
-	ReportDaily    ReportKind = "daily"
-	ReportTomorrow ReportKind = "tomorrow"
-	ReportHourly   ReportKind = "hourly"
-	ReportThreeDay ReportKind = "three-day"
-	ReportWeekend  ReportKind = "weekend"
-	ReportStorm    ReportKind = "storm"
+	ReportDaily    ReportKind = ReportKind(report.CommandNameDaily)
+	ReportToday    ReportKind = ReportKind(report.CommandNameToday)
+	ReportTomorrow ReportKind = ReportKind(report.CommandNameTomorrow)
+	ReportHourly   ReportKind = ReportKind(report.CommandNameHourly)
+	ReportThreeDay ReportKind = ReportKind(report.CommandNameThreeDay)
+	ReportWeekend  ReportKind = ReportKind(report.CommandNameWeekend)
+	ReportStorm    ReportKind = ReportKind(report.CommandNameStorm)
 )
 
 type BatchKind string
 
 const (
-	BatchMorning BatchKind = "morning"
-	BatchEvening BatchKind = "evening"
+	BatchMorning BatchKind = BatchKind(report.BatchNameMorning)
+	BatchEvening BatchKind = BatchKind(report.BatchNameEvening)
 )
 
 type GenerateRequest struct {
@@ -53,6 +53,7 @@ type GenerateRequest struct {
 	Date       time.Time
 	StormStart time.Time
 	StormEnd   time.Time
+	Collector  Collector
 	Notifier   Notifier
 }
 
@@ -61,6 +62,7 @@ type BatchRequest struct {
 	Batch     BatchKind
 	Now       time.Time
 	OutputDir string
+	Collector Collector
 	Renderer  Renderer
 	Store     state.Store
 	Notifier  Notifier
@@ -85,9 +87,11 @@ type ReportRequest struct {
 	Config     config.Config
 	Resolved   report.Resolved
 	OutputPath string
+	Collection collect.Result
 	Renderer   Renderer
 	Store      state.Store
 	Notifier   Notifier
+	noNotify   bool
 }
 
 type ReportResult struct {
@@ -120,9 +124,29 @@ type BatchResult struct {
 	Total        int                      `json:"total"`
 	Succeeded    int                      `json:"succeeded"`
 	Failed       int                      `json:"failed"`
+	Notification *BatchNotificationResult `json:"notification,omitempty"`
 	Reports      []BatchReportResult      `json:"reports"`
 }
 
+type BatchNotificationResult struct {
+	Status          string                    `json:"status"`
+	Reason          string                    `json:"reason,omitempty"`
+	RunID           string                    `json:"runId,omitempty"`
+	PipelineID      string                    `json:"pipelineId,omitempty"`
+	BundleID        string                    `json:"bundleId,omitempty"`
+	IdempotencyKey  string                    `json:"idempotencyKey,omitempty"`
+	Path            string                    `json:"path,omitempty"`
+	IncludedReports []BatchNotificationReport `json:"includedReports,omitempty"`
+	Error           string                    `json:"error,omitempty"`
+}
+
+type BatchNotificationReport struct {
+	ReportID    report.ID `json:"reportId"`
+	RunID       string    `json:"runId"`
+	SourcePath  string    `json:"sourcePath"`
+	BundlePaths []string  `json:"bundlePaths"`
+}
+
 type BatchReportResult struct {
 	ReportID               report.ID       `json:"reportId"`
 	ReportName             string          `json:"reportName"`
@@ -152,15 +176,48 @@ func (e BatchError) Error() string {
 	if e.Result == nil {
 		return "batch failed"
 	}
+	if batchNotificationFailed(e.Result) && batchReportFailures(e.Result) == 0 {
+		if e.Result.Notification.Error != "" {
+			return fmt.Sprintf("batch %s notification failed: %s", e.Result.Batch, e.Result.Notification.Error)
+		}
+		return fmt.Sprintf("batch %s notification failed", e.Result.Batch)
+	}
 	return fmt.Sprintf("batch %s failed: %d of %d reports failed", e.Result.Batch, e.Result.Failed, e.Result.Total)
 }
 
+func batchNotificationFailed(result *BatchResult) bool {
+	return result != nil && result.Notification != nil && result.Notification.Status == "failed"
+}
+
+func batchReportFailures(result *BatchResult) int {
+	if result == nil {
+		return 0
+	}
+	failures := 0
+	for _, item := range result.Reports {
+		if item.Status == "failed" {
+			failures++
+		}
+	}
+	return failures
+}
+
 type Renderer interface {
 	Render(context.Context, scriptorium.RenderRequest) (*scriptorium.RenderResult, error)
 	Run(context.Context, scriptorium.RunRequest) (*scriptorium.RunResult, error)
 	StructuredRun(context.Context, scriptorium.StructuredRunRequest) (*scriptorium.StructuredRunResult, error)
 }
 
+type Collector interface {
+	Run(context.Context, collect.Request) (*collect.Result, error)
+}
+
+type defaultCollector struct{}
+
+func (defaultCollector) Run(ctx context.Context, req collect.Request) (*collect.Result, error) {
+	return collect.Run(ctx, req)
+}
+
 type Notifier interface {
 	Notify(context.Context, NotificationRequest) (*NotificationResult, error)
 }
@@ -211,24 +268,33 @@ func (e *NotificationError) Unwrap() error {
 }
 
 func Generate(ctx context.Context, req GenerateRequest) error {
+	_, err := GenerateDetailed(ctx, req)
+	return err
+}
+
+func GenerateDetailed(ctx context.Context, req GenerateRequest) (*ReportResult, error) {
 	now := req.Now
 	if now.IsZero() {
 		now = time.Now()
 	}
+	collection, err := collectWeather(ctx, req.Config, req.Collector)
+	if err != nil {
+		return nil, err
+	}
 	resolved, err := ResolveGenerate(req, now)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if resolved.Definition.Generated {
-		_, err := GenerateReport(ctx, ReportRequest{
+		return GenerateReport(ctx, ReportRequest{
 			Config:     req.Config,
 			Resolved:   resolved,
 			OutputPath: req.OutputPath,
+			Collection: *collection,
 			Notifier:   req.Notifier,
 		})
-		return err
 	}
-	return fmt.Errorf("generate is not implemented")
+	return nil, fmt.Errorf("generate is not implemented")
 }
 
 func RunBatch(ctx context.Context, req BatchRequest) error {
@@ -247,7 +313,14 @@ func RunBatchDetailed(ctx context.Context, req BatchRequest) (*BatchResult, erro
 	if now.IsZero() {
 		now = time.Now()
 	}
-	resolvedReports, err := ResolveBatch(req, now)
+	if _, err := report.BatchForCommandName(string(req.Batch)); err != nil {
+		return nil, err
+	}
+	collection, err := collectWeather(ctx, req.Config, req.Collector)
+	if err != nil {
+		return nil, err
+	}
+	plannedReports, err := planBatchRun(req, now, *collection)
 	if err != nil {
 		return nil, err
 	}
@@ -262,27 +335,31 @@ func RunBatchDetailed(ctx context.Context, req BatchRequest) (*BatchResult, erro
 		}
 		startedAt := now
 		result := &BatchResult{Batch: req.Batch, StartedAt: startedAt}
-		for _, resolved := range resolvedReports {
+		for _, planned := range plannedReports {
+			resolved := planned.Resolved
 			if !resolved.Definition.Generated {
 				return nil, fmt.Errorf("run is not implemented")
 			}
 		}
-		for _, resolved := range resolvedReports {
-			item := batchReportResult(resolved)
+		for _, planned := range plannedReports {
+			resolved := planned.Resolved
+			item := batchReportResult(planned)
 			if paths, err := store.Paths(resolved); err == nil {
 				item.DataPackagePath = paths.DataPackage
 				item.PreflightPath = paths.Preflight
 				item.ReportPath = paths.RenderedReport
 				item.MetadataPath = paths.Metadata
 			}
-			outputPath := batchOutputPath(req.OutputDir, resolved.Definition)
+			outputPath := plannedBatchOutputPath(req.OutputDir, planned)
 			reportResult, err := GenerateReport(ctx, ReportRequest{
 				Config:     req.Config,
 				Resolved:   resolved,
 				OutputPath: outputPath,
+				Collection: *collection,
 				Renderer:   req.Renderer,
 				Store:      store,
 				Notifier:   req.Notifier,
+				noNotify:   true,
 			})
 			if err != nil {
 				item.Status = "failed"
@@ -315,13 +392,21 @@ func RunBatchDetailed(ctx context.Context, req BatchRequest) (*BatchResult, erro
 			result.Reports = append(result.Reports, item)
 		}
 		result.Total = len(result.Reports)
+		batchNotification, err := notifyBatch(ctx, req.Config, req.Batch, batchRunID(startedAt, req.Batch), startedAt, result, plannedReports, store, req.Notifier)
+		if batchNotification != nil {
+			result.Notification = batchNotification
+		}
+		if err != nil {
+			result.Failed++
+		}
 		result.FinishedAt = time.Now()
 		return result, nil
 	}
 	return nil, fmt.Errorf("run is not implemented")
 }
 
-func batchReportResult(resolved report.Resolved) BatchReportResult {
+func batchReportResult(planned plannedBatchReport) BatchReportResult {
+	resolved := planned.Resolved
 	metadata := resolved.Metadata()
 	return BatchReportResult{
 		ReportID:    resolved.Definition.ID,
@@ -333,11 +418,18 @@ func batchReportResult(resolved report.Resolved) BatchReportResult {
 	}
 }
 
-func batchOutputPath(outputDir string, definition report.Definition) string {
-	if outputDir == "" || definition.BatchOutputName == "" {
+func plannedBatchOutputPath(outputDir string, planned plannedBatchReport) string {
+	if outputDir == "" {
 		return ""
 	}
-	return filepath.Join(outputDir, definition.BatchOutputName)
+	outputCopyName := planned.OutputCopyName
+	if outputCopyName == "" {
+		outputCopyName = planned.Resolved.Definition.BatchOutputName
+	}
+	if outputCopyName == "" {
+		return ""
+	}
+	return filepath.Join(outputDir, outputCopyName)
 }
 
 func ResolveGenerate(req GenerateRequest, now time.Time) (report.Resolved, error) {
@@ -345,7 +437,7 @@ func ResolveGenerate(req GenerateRequest, now time.Time) (report.Resolved, error
 	if err != nil {
 		return report.Resolved{}, err
 	}
-	id, err := reportIDForCommand(req.Report)
+	id, err := report.IDForCommandName(string(req.Report))
 	if err != nil {
 		return report.Resolved{}, err
 	}
@@ -362,73 +454,41 @@ func ResolveGenerate(req GenerateRequest, now time.Time) (report.Resolved, error
 	})
 }
 
-func ResolveBatch(req BatchRequest, now time.Time) ([]report.Resolved, error) {
-	location, err := timeutil.LoadLocation(req.Config.WeatherAPI.Timezone)
-	if err != nil {
-		return nil, err
-	}
-	batch, err := reportBatchForCommand(req.Batch)
-	if err != nil {
-		return nil, err
-	}
-	registry, err := reportRegistry(req.Config)
-	if err != nil {
-		return nil, err
-	}
-	return registry.BatchReports(batch, report.ResolveRequest{
-		Now:      now,
-		Location: location,
-	})
-}
-
 func reportRegistry(cfg config.Config) (report.Registry, error) {
-	registry, err := report.DefaultRegistry().WithModuleOverrides(cfg.ReportModuleOverrides())
+	overrides, err := cfg.ReportModuleOverrides()
+	if err != nil {
+		return report.Registry{}, err
+	}
+	registry, err := report.DefaultRegistry().WithModuleOverrides(overrides)
 	if err != nil {
 		return report.Registry{}, err
 	}
 	return registry, nil
 }
 
-func reportIDForCommand(kind ReportKind) (report.ID, error) {
-	switch kind {
-	case ReportDaily:
-		return report.DailyToday, nil
-	case ReportTomorrow:
-		return report.Tomorrow, nil
-	case ReportHourly:
-		return report.Hourly, nil
-	case ReportThreeDay:
-		return report.ThreeDay, nil
-	case ReportWeekend:
-		return report.Weekend, nil
-	case ReportStorm:
-		return report.Storm, nil
-	default:
-		return "", fmt.Errorf("unknown report command %q", kind)
-	}
-}
-
-func reportBatchForCommand(kind BatchKind) (report.Batch, error) {
-	switch kind {
-	case BatchMorning:
-		return report.Morning, nil
-	case BatchEvening:
-		return report.Evening, nil
-	default:
-		return "", fmt.Errorf("unknown batch command %q", kind)
-	}
-}
-
 func FetchBundle(ctx context.Context, req FetchBundleRequest) (*weatherdata.Bundle, error) {
-	client, err := weatherapi.New(req.Config)
+	result, err := collectWeather(ctx, req.Config, nil)
 	if err != nil {
 		return nil, err
 	}
-	bundle, err := client.FetchBundle(ctx)
+	return result.Bundle, nil
+}
+
+func collectWeather(ctx context.Context, cfg config.Config, collector Collector) (*collect.Result, error) {
+	if collector == nil {
+		collector = defaultCollector{}
+	}
+	result, err := collector.Run(ctx, collect.Request{Config: cfg})
 	if err != nil {
 		return nil, err
 	}
-	return bundle, nil
+	if result == nil {
+		return nil, fmt.Errorf("collect weather bundle: collector returned nil result")
+	}
+	if result.Bundle == nil {
+		return nil, fmt.Errorf("collect weather bundle: collector returned nil bundle")
+	}
+	return result, nil
 }
 
 func FetchAndSaveBundle(ctx context.Context, req FetchBundleRequest) (*weatherdata.Bundle, error) {
@@ -439,13 +499,18 @@ func FetchAndSaveBundle(ctx context.Context, req FetchBundleRequest) (*weatherda
 	if err != nil {
 		return nil, err
 	}
-	if err := weatherapi.SaveBundle(req.OutputPath, bundle); err != nil {
-		return nil, err
+	if err := fileutil.WriteJSONAtomic(req.OutputPath, bundle); err != nil {
+		return nil, fmt.Errorf("save bundle: %w", err)
 	}
 	return bundle, nil
 }
 
 func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, error) {
+	bundle := req.Collection.Bundle
+	if bundle == nil {
+		return nil, fmt.Errorf("collected weather bundle is required")
+	}
+
 	store := req.Store
 	if store == nil {
 		defaultStore, err := defaultStore(req.Config)
@@ -463,10 +528,6 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 		return nil, err
 	}
 
-	bundle, err := FetchBundle(ctx, FetchBundleRequest{Config: req.Config})
-	if err != nil {
-		return nil, err
-	}
 	reportFacts, err := BuildReportFacts(ModuleSnapshotRequest{
 		Config:   req.Config,
 		Resolved: req.Resolved,
@@ -585,53 +646,49 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 		DataPackagePath: dataPackagePath,
 		OutputPath:      reportPath,
 	})
-	if runErr == nil && req.OutputPath != "" && req.OutputPath != reportPath {
-		if err := fileutil.CopyFileAtomic(reportPath, req.OutputPath); err != nil {
-			return nil, err
-		}
-	}
-	outputPath := reportPath
-	if req.OutputPath != "" {
-		outputPath = req.OutputPath
-	}
-	metadata.RenderedReportPath = reportPath
-	metadataPath, metadataErr = store.SaveMetadata(ctx, metadata)
-	if metadataErr != nil {
-		return nil, metadataErr
-	}
-	if runErr != nil {
-		return nil, runErr
-	}
-
-	notification, notificationPath, err := notifyReport(ctx, req.Config, req.Resolved, reportPath, metadata, req.Notifier, store)
-	if notificationPath != "" {
-		metadata.NotificationPath = notificationPath
-		metadataPath, metadataErr = store.SaveMetadata(ctx, metadata)
-		if metadataErr != nil {
-			return nil, metadataErr
-		}
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	return &ReportResult{
-		ModuleSnapshot:     moduleSnapshot,
-		ModuleSnapshotPath: moduleSnapshotPath,
-		DataPackage:        dataPackage,
-		DataPackagePath:    dataPackagePath,
-		PreflightPath:      preflightPath,
-		ReportPath:         reportPath,
-		OutputPath:         outputPath,
-		NotificationPath:   notificationPath,
+	finalized, err := finalizeRenderedReport(ctx, finalizeRenderedReportRequest{
+		Config:            req.Config,
+		Store:             store,
+		Resolved:          req.Resolved,
 		Metadata:          metadata,
-		MetadataPath:       metadataPath,
-		PriorSnapshot:      priorSnapshot,
-		RecentChanges:      recentChanges,
-		RenderResult:       renderResult,
-		RunResult:          runResult,
-		Notification:       notification,
-	}, nil
+		ManagedReportPath: reportPath,
+		OutputPath:        req.OutputPath,
+		Notifier:          req.Notifier,
+		GenerationErr:     runErr,
+		noNotify:          req.noNotify,
+	})
+	if err != nil {
+		if finalizeResultEmpty(finalized) {
+			return nil, err
+		}
+		return renderedReportResult(reportResultRequest{
+			moduleSnapshot:     moduleSnapshot,
+			moduleSnapshotPath: moduleSnapshotPath,
+			dataPackage:        dataPackage,
+			dataPackagePath:    dataPackagePath,
+			preflightPath:      preflightPath,
+			reportPath:         reportPath,
+			finalized:          finalized,
+			priorSnapshot:      priorSnapshot,
+			recentChanges:      recentChanges,
+			renderResult:       renderResult,
+			runResult:          runResult,
+		}), err
+	}
+
+	return renderedReportResult(reportResultRequest{
+		moduleSnapshot:     moduleSnapshot,
+		moduleSnapshotPath: moduleSnapshotPath,
+		dataPackage:        dataPackage,
+		dataPackagePath:    dataPackagePath,
+		preflightPath:      preflightPath,
+		reportPath:         reportPath,
+		finalized:          finalized,
+		priorSnapshot:      priorSnapshot,
+		recentChanges:      recentChanges,
+		renderResult:       renderResult,
+		runResult:          runResult,
+	}), nil
 }
 
 type generatedReportRequest struct {
@@ -654,6 +711,11 @@ type generatedReportRequest struct {
 }
 
 func generateTextTemplateReport(ctx context.Context, req generatedReportRequest) (*ReportResult, error) {
+	handler, err := generatedtext.LookupDefinition(req.Resolved.Definition)
+	if err != nil {
+		return nil, generatedReportError(req.Resolved, req.metadata.RunID, "lookup generated text catalog", err)
+	}
+
 	structuredResult, runErr := req.renderer.StructuredRun(ctx, scriptorium.StructuredRunRequest{
 		PromptID:        req.Resolved.Definition.PromptID,
 		DataPackagePath: req.dataPackagePath,
@@ -680,7 +742,7 @@ func generateTextTemplateReport(ctx context.Context, req generatedReportRequest)
 	if err != nil {
 		return nil, generatedReportError(req.Resolved, req.metadata.RunID, "load raw generated text", err)
 	}
-	generatedText, normalizedGeneratedText, err := validateGeneratedText(req.Resolved.Definition, rawGeneratedText)
+	generatedText, normalizedGeneratedText, err := handler.Validate(rawGeneratedText)
 	if err != nil {
 		return nil, generatedReportError(req.Resolved, req.metadata.RunID, "validate generated text", err)
 	}
@@ -694,7 +756,7 @@ func generateTextTemplateReport(ctx context.Context, req generatedReportRequest)
 		return nil, err
 	}
 
-	renderContext, err := buildRenderContext(req.Resolved.Definition, req.briefingMetadata, req.moduleSnapshot, req.reportFacts, generatedText)
+	renderContext, err := handler.BuildRenderContext(req.briefingMetadata, req.moduleSnapshot, req.reportFacts.Collected, req.reportFacts.Derived, generatedText)
 	if err != nil {
 		return nil, generatedReportError(req.Resolved, req.metadata.RunID, "build render context", err)
 	}
@@ -708,7 +770,7 @@ func generateTextTemplateReport(ctx context.Context, req generatedReportRequest)
 		return nil, err
 	}
 
-	rendered, err := reporttemplate.Render(req.Resolved.Definition.TemplateID, renderContext)
+	rendered, err := handler.Render(renderContext)
 	if err != nil {
 		return nil, generatedReportError(req.Resolved, req.metadata.RunID, "render template", err)
 	}
@@ -719,54 +781,182 @@ func generateTextTemplateReport(ctx context.Context, req generatedReportRequest)
 	if err := fileutil.WriteFileAtomic(reportPath, rendered); err != nil {
 		return nil, err
 	}
-	req.metadata.RenderedReportPath = reportPath
-	metadataPath, err := req.store.SaveMetadata(ctx, req.metadata)
+	finalized, err := finalizeRenderedReport(ctx, finalizeRenderedReportRequest{
+		Config:            req.Config,
+		Store:             req.store,
+		Resolved:          req.Resolved,
+		Metadata:          req.metadata,
+		ManagedReportPath: reportPath,
+		OutputPath:        req.OutputPath,
+		Notifier:          req.Notifier,
+		noNotify:          req.noNotify,
+	})
 	if err != nil {
+		if finalizeResultEmpty(finalized) {
 			return nil, err
 		}
-	outputPath := reportPath
-	if req.OutputPath != "" {
-		outputPath = req.OutputPath
-		if req.OutputPath != reportPath {
-			if err := fileutil.CopyFileAtomic(reportPath, req.OutputPath); err != nil {
-				return nil, err
-			}
-		}
+		return renderedReportResult(reportResultRequest{
+			moduleSnapshot:          req.moduleSnapshot,
+			moduleSnapshotPath:      req.moduleSnapshotPath,
+			dataPackage:             req.dataPackage,
+			dataPackagePath:         req.dataPackagePath,
+			preflightPath:           req.preflightPath,
+			reportPath:              reportPath,
+			finalized:               finalized,
+			priorSnapshot:           req.priorSnapshot,
+			recentChanges:           req.recentChanges,
+			renderResult:            req.renderResult,
+			structuredRunResult:     structuredResult,
+			generatedTextRawPath:    req.paths.GeneratedTextRaw,
+			generatedTextResultPath: generatedTextResultPath,
+			generatedTextPath:       generatedTextPath,
+			renderContextPath:       renderContextPath,
+		}), err
 	}
 
-	notification, notificationPath, notificationErr := notifyReport(ctx, req.Config, req.Resolved, reportPath, req.metadata, req.Notifier, req.store)
-	if notificationPath != "" {
-		req.metadata.NotificationPath = notificationPath
-		metadataPath, err = req.store.SaveMetadata(ctx, req.metadata)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if notificationErr != nil {
-		return nil, notificationErr
-	}
+	return renderedReportResult(reportResultRequest{
+		moduleSnapshot:          req.moduleSnapshot,
+		moduleSnapshotPath:      req.moduleSnapshotPath,
+		dataPackage:             req.dataPackage,
+		dataPackagePath:         req.dataPackagePath,
+		preflightPath:           req.preflightPath,
+		reportPath:              reportPath,
+		finalized:               finalized,
+		priorSnapshot:           req.priorSnapshot,
+		recentChanges:           req.recentChanges,
+		renderResult:            req.renderResult,
+		structuredRunResult:     structuredResult,
+		generatedTextRawPath:    req.paths.GeneratedTextRaw,
+		generatedTextResultPath: generatedTextResultPath,
+		generatedTextPath:       generatedTextPath,
+		renderContextPath:       renderContextPath,
+	}), nil
+}
 
+func finalizeResultEmpty(result finalizeRenderedReportResult) bool {
+	return result.OutputPath == "" &&
+		result.NotificationPath == "" &&
+		result.MetadataPath == "" &&
+		result.Metadata.RunID == "" &&
+		result.Notification == nil
+}
+
+type reportResultRequest struct {
+	moduleSnapshot          module.Snapshot
+	moduleSnapshotPath      string
+	dataPackage             promptinput.Package
+	dataPackagePath         string
+	preflightPath           string
+	reportPath              string
+	finalized               finalizeRenderedReportResult
+	priorSnapshot           *state.PriorSnapshot
+	recentChanges           []changes.Change
+	renderResult            *scriptorium.RenderResult
+	runResult               *scriptorium.RunResult
+	structuredRunResult     *scriptorium.StructuredRunResult
+	generatedTextRawPath    string
+	generatedTextResultPath string
+	generatedTextPath       string
+	renderContextPath       string
+}
+
+func renderedReportResult(req reportResultRequest) *ReportResult {
 	return &ReportResult{
 		ModuleSnapshot:          req.moduleSnapshot,
 		ModuleSnapshotPath:      req.moduleSnapshotPath,
 		DataPackage:             req.dataPackage,
 		DataPackagePath:         req.dataPackagePath,
 		PreflightPath:           req.preflightPath,
-		ReportPath:              reportPath,
-		OutputPath:              outputPath,
-		NotificationPath:        notificationPath,
-		Metadata:                req.metadata,
-		MetadataPath:            metadataPath,
+		ReportPath:              req.reportPath,
+		OutputPath:              req.finalized.OutputPath,
+		NotificationPath:        req.finalized.NotificationPath,
+		Metadata:                req.finalized.Metadata,
+		MetadataPath:            req.finalized.MetadataPath,
 		PriorSnapshot:           req.priorSnapshot,
 		RecentChanges:           req.recentChanges,
 		RenderResult:            req.renderResult,
-		StructuredRunResult:     structuredResult,
-		GeneratedTextRawPath:    req.paths.GeneratedTextRaw,
-		GeneratedTextResultPath: generatedTextResultPath,
-		GeneratedTextPath:       generatedTextPath,
-		RenderContextPath:       renderContextPath,
-		Notification:            notification,
-	}, nil
+		RunResult:               req.runResult,
+		StructuredRunResult:     req.structuredRunResult,
+		GeneratedTextRawPath:    req.generatedTextRawPath,
+		GeneratedTextResultPath: req.generatedTextResultPath,
+		GeneratedTextPath:       req.generatedTextPath,
+		RenderContextPath:       req.renderContextPath,
+		Notification:            req.finalized.Notification,
+	}
+}
+
+type finalizeRenderedReportRequest struct {
+	Config            config.Config
+	Store             state.Store
+	Resolved          report.Resolved
+	Metadata          state.Metadata
+	ManagedReportPath string
+	OutputPath        string
+	Notifier          Notifier
+	GenerationErr     error
+	noNotify          bool
+}
+
+type finalizeRenderedReportResult struct {
+	OutputPath       string
+	NotificationPath string
+	Metadata         state.Metadata
+	MetadataPath     string
+	Notification     *NotificationResult
+}
+
+func finalizeRenderedReport(ctx context.Context, req finalizeRenderedReportRequest) (finalizeRenderedReportResult, error) {
+	if req.Store == nil {
+		return finalizeRenderedReportResult{}, fmt.Errorf("state store is required")
+	}
+	if req.ManagedReportPath == "" {
+		return finalizeRenderedReportResult{}, fmt.Errorf("managed report path is required for report %q", req.Resolved.Definition.ID)
+	}
+
+	metadata := req.Metadata
+	metadata.RenderedReportPath = req.ManagedReportPath
+	outputPath := req.ManagedReportPath
+	if req.OutputPath != "" {
+		outputPath = req.OutputPath
+		if req.GenerationErr == nil && req.OutputPath != req.ManagedReportPath {
+			if err := fileutil.CopyFileAtomic(req.ManagedReportPath, req.OutputPath); err != nil {
+				return finalizeRenderedReportResult{}, err
+			}
+		}
+	}
+
+	metadataPath, err := req.Store.SaveMetadata(ctx, metadata)
+	if err != nil {
+		return finalizeRenderedReportResult{}, err
+	}
+	result := finalizeRenderedReportResult{
+		OutputPath:   outputPath,
+		Metadata:     metadata,
+		MetadataPath: metadataPath,
+	}
+	if req.GenerationErr != nil {
+		return result, req.GenerationErr
+	}
+	if req.noNotify {
+		return result, nil
+	}
+
+	notification, notificationPath, err := notifyReport(ctx, req.Config, req.Resolved, req.ManagedReportPath, metadata, req.Notifier, req.Store)
+	if notificationPath != "" {
+		metadata.NotificationPath = notificationPath
+		metadataPath, saveErr := req.Store.SaveMetadata(ctx, metadata)
+		if saveErr != nil {
+			return finalizeRenderedReportResult{}, saveErr
+		}
+		result.Metadata = metadata
+		result.MetadataPath = metadataPath
+		result.NotificationPath = notificationPath
+	}
+	result.Notification = notification
+	if err != nil {
+		return result, err
+	}
+	return result, nil
 }
 
 func notifyReport(ctx context.Context, cfg config.Config, resolved report.Resolved, reportPath string, metadata state.Metadata, notifier Notifier, store state.Store) (*NotificationResult, string, error) {
@@ -809,14 +999,8 @@ func reportNotifier(cfg config.Config, notifier Notifier) (Notifier, bool) {
 }
 
 func buildNotificationRequest(cfg config.Config, resolved report.Resolved, reportPath string, metadata state.Metadata) (NotificationRequest, error) {
-	values := config.DistributorTemplateValues{
-		LocationID:      cfg.Location.ID,
-		ReportID:        string(resolved.Definition.ID),
-		RunID:           metadata.RunID,
-		ArtifactGroup:   resolved.Definition.ArtifactGroup,
-		BatchOutputName: resolved.Definition.BatchOutputName,
-	}
-	if err := addDistributorValidPeriodValues(&values, resolved.ValidPeriod, cfg.WeatherAPI.Timezone); err != nil {
+	values, err := distributorTemplateValuesForReport(cfg, resolved, metadata.RunID, resolved.Definition.BatchOutputName)
+	if err != nil {
 		return NotificationRequest{}, err
 	}
 	bundleID, err := config.RenderDistributorBundleID(cfg.Notify.Distributor.BundleIDTemplate, values)
@@ -832,7 +1016,7 @@ func buildNotificationRequest(cfg config.Config, resolved report.Resolved, repor
 	if err != nil {
 		return NotificationRequest{}, err
 	}
-	bundlePaths, err := config.RenderDistributorReportPaths(cfg.Notify.Distributor.ReportPathTemplates, values)
+	bundlePaths, err := renderDistributorReportBundlePaths(cfg, resolved, metadata.RunID, reportPath, values)
 	if err != nil {
 		return NotificationRequest{}, err
 	}
@@ -848,6 +1032,59 @@ func buildNotificationRequest(cfg config.Config, resolved report.Resolved, repor
 	}, nil
 }
 
+func distributorTemplateValuesForReport(cfg config.Config, resolved report.Resolved, runID string, batchOutputName string) (config.DistributorTemplateValues, error) {
+	values := config.DistributorTemplateValues{
+		LocationID:      cfg.Location.ID,
+		ReportID:        string(resolved.Definition.ID),
+		RunID:           runID,
+		ArtifactGroup:   resolved.Definition.ArtifactGroup,
+		BatchOutputName: batchOutputName,
+	}
+	if values.BatchOutputName == "" {
+		values.BatchOutputName = resolved.Definition.BatchOutputName
+	}
+	if err := addDistributorValidPeriodValues(&values, resolved.ValidPeriod, cfg.WeatherAPI.Timezone); err != nil {
+		return config.DistributorTemplateValues{}, err
+	}
+	if resolved.Definition.ID == report.Storm {
+		values.StormID = values.ValidStartStamp + "-" + values.ValidEndStamp
+	}
+	return values, nil
+}
+
+func renderDistributorReportBundlePaths(cfg config.Config, resolved report.Resolved, runID string, sourcePath string, values config.DistributorTemplateValues) ([]string, error) {
+	templates, name, err := distributorPathTemplatesForReport(cfg, resolved.Definition)
+	if err != nil {
+		return nil, distributorReportPathError(resolved.Definition.ID, runID, sourcePath, err)
+	}
+	paths, err := config.RenderDistributorReportPaths(name, templates, values)
+	if err != nil {
+		return nil, distributorReportPathError(resolved.Definition.ID, runID, sourcePath, err)
+	}
+	return paths, nil
+}
+
+func distributorPathTemplatesForReport(cfg config.Config, definition report.Definition) ([]string, string, error) {
+	overrides, err := cfg.ReportDistributorPathOverrides()
+	if err != nil {
+		return nil, "", err
+	}
+	if templates, ok := overrides[definition.ID]; ok {
+		return append([]string(nil), templates...), fmt.Sprintf("reports.%s.distributor.path_templates", definition.ID), nil
+	}
+	if len(definition.DistributorPathTemplates) > 0 {
+		return append([]string(nil), definition.DistributorPathTemplates...), fmt.Sprintf("report.%s.distributor_path_templates", definition.ID), nil
+	}
+	return nil, "", fmt.Errorf("no distributor path templates configured")
+}
+
+func distributorReportPathError(id report.ID, runID string, sourcePath string, err error) error {
+	if sourcePath != "" {
+		return fmt.Errorf("report %q run %q source path %q: %w", id, runID, sourcePath, err)
+	}
+	return fmt.Errorf("report %q run %q: %w", id, runID, err)
+}
+
 func addDistributorValidPeriodValues(values *config.DistributorTemplateValues, period timeutil.Period, timezone string) error {
 	location, err := timeutil.LoadLocation(timezone)
 	if err != nil {
@@ -955,6 +1192,38 @@ func (n distributorNotifier) Notify(ctx context.Context, req NotificationRequest
 	return notification, nil
 }
 
+func (n distributorNotifier) NotifyBatch(ctx context.Context, req batchNotificationRequest) (*NotificationResult, error) {
+	result, err := n.client.Upload(ctx, batchDistributorUploadRequest(req))
+	notification := notificationResultFromUpload(req.PipelineID, req.BundleID, req.IdempotencyKey, result)
+	if err != nil {
+		return notification, err
+	}
+	return notification, nil
+}
+
+func notificationResultFromUpload(pipelineID string, bundleID string, idempotencyKey string, result distributoradapter.UploadResult) *NotificationResult {
+	notification := &NotificationResult{
+		PipelineID:     pipelineID,
+		BundleID:       bundleID,
+		IdempotencyKey: idempotencyKey,
+		RunID:          result.RunID,
+		Status:         result.Status,
+		UploadStatus:   result.UploadStatus,
+		StatusError:    result.StatusError,
+	}
+	if result.RunStatus != nil {
+		if result.RunStatus.PipelineID != "" {
+			notification.PipelineID = result.RunStatus.PipelineID
+		}
+		notification.AcceptedAt = result.RunStatus.AcceptedAt
+		notification.StartedAt = result.RunStatus.StartedAt
+		notification.FinishedAt = result.RunStatus.FinishedAt
+		notification.Report = append([]byte(nil), result.RunStatus.Report...)
+		notification.Error = result.RunStatus.Error
+	}
+	return notification
+}
+
 func distributorUploadFiles(sourcePath string, bundlePaths []string) []distributoradapter.UploadFile {
 	files := make([]distributoradapter.UploadFile, 0, len(bundlePaths))
 	for _, bundlePath := range bundlePaths {
@@ -1088,7 +1357,7 @@ func recentChanges(ctx context.Context, store state.Store, priorSnapshot *state.
 		PrecipTimingShiftMinutes: cfg.PrecipTimingShiftMinutes,
 	}
 	switch reportID {
-	case report.DailyToday, report.Tomorrow:
+	case report.Daily, report.Today, report.Tomorrow:
 		return changes.CompareDaily(previous, current, thresholds)
 	case report.ThreeDay:
 		return changes.CompareThreeDay(previous, current, thresholds)
@@ -1113,36 +1382,6 @@ func preflightArtifact(result *scriptorium.RenderResult) state.PreflightArtifact
 	}
 }
 
-func validateGeneratedText(definition report.Definition, data []byte) (any, []byte, error) {
-	switch definition.GeneratedTextSchemaID {
-	case "hourly":
-		return generatedtext.ValidateHourly(data)
-	case "tomorrow":
-		return generatedtext.ValidateTomorrow(data)
-	default:
-		return nil, nil, fmt.Errorf("generated text schema %q is not supported for report %q", definition.GeneratedTextSchemaID, definition.ID)
-	}
-}
-
-func buildRenderContext(definition report.Definition, metadata briefing.Metadata, snapshot module.Snapshot, reportFacts ReportFacts, generated any) (any, error) {
-	switch definition.TemplateID {
-	case "hourly":
-		hourly, ok := generated.(generatedtext.Hourly)
-		if !ok {
-			return nil, fmt.Errorf("report template %q requires hourly generated text for report %q", definition.TemplateID, definition.ID)
-		}
-		return generatedtext.BuildHourlyRenderContext(metadata, snapshot, hourly, reportFacts.Collected, reportFacts.Derived)
-	case "tomorrow":
-		tomorrow, ok := generated.(generatedtext.Tomorrow)
-		if !ok {
-			return nil, fmt.Errorf("report template %q requires tomorrow generated text for report %q", definition.TemplateID, definition.ID)
-		}
-		return generatedtext.BuildTomorrowRenderContext(metadata, snapshot, tomorrow, reportFacts.Collected, reportFacts.Derived)
-	default:
-		return nil, fmt.Errorf("report template %q is not supported for report %q", definition.TemplateID, definition.ID)
-	}
-}
-
 func generatedReportError(resolved report.Resolved, runID string, operation string, err error) error {
 	if err == nil {
 		return nil

internal/app/batch_notification.go

@@ -0,0 +1,379 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	distributoradapter "gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/distributor"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/state"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+)
+
+const runIDTimestampLayout = "20060102T150405.000000000Z"
+
+type batchNotificationIdentity struct {
+	PipelineID     string
+	BundleID       string
+	IdempotencyKey string
+}
+
+type batchNotificationRequest struct {
+	Batch           BatchKind
+	RunID           string
+	PipelineID      string
+	BundleID        string
+	IdempotencyKey  string
+	Files           []batchNotificationFile
+	IncludedReports []BatchNotificationReport
+	CreatedAt       time.Time
+}
+
+type batchNotificationFile struct {
+	ReportID   report.ID
+	RunID      string
+	SourcePath string
+	BundlePath string
+}
+
+type batchNotifier interface {
+	NotifyBatch(context.Context, batchNotificationRequest) (*NotificationResult, error)
+}
+
+func batchRunID(startedAt time.Time, batch BatchKind) string {
+	return startedAt.UTC().Format(runIDTimestampLayout) + "_" + string(batch)
+}
+
+func notifyBatch(ctx context.Context, cfg config.Config, batch BatchKind, runID string, startedAt time.Time, result *BatchResult, planned []plannedBatchReport, store state.Store, notifier Notifier) (*BatchNotificationResult, error) {
+	if !cfg.Notify.Distributor.Enabled {
+		return nil, nil
+	}
+	if !cfg.Notify.Distributor.Batch.Enabled {
+		return nil, nil
+	}
+	if result == nil {
+		return nil, fmt.Errorf("batch result is required")
+	}
+	if result.Failed > 0 {
+		return &BatchNotificationResult{
+			Status: "skipped",
+			Reason: "one or more reports failed",
+		}, nil
+	}
+
+	req, err := buildBatchNotificationRequest(cfg, batch, runID, startedAt, result.Reports, planned)
+	if err != nil {
+		path, saveErr := saveBatchNotificationArtifact(ctx, store, cfg, batch, runID, startedAt, batchNotificationRequest{}, nil, err)
+		if saveErr != nil {
+			return nil, saveErr
+		}
+		return failedBatchNotificationResult(batchNotificationRequest{}, path, err), err
+	}
+
+	batchNotifier, err := resolveBatchNotifier(cfg, notifier)
+	if err != nil {
+		path, saveErr := saveBatchNotificationArtifact(ctx, store, cfg, batch, runID, startedAt, req, nil, err)
+		if saveErr != nil {
+			return nil, saveErr
+		}
+		return failedBatchNotificationResult(req, path, err), err
+	}
+
+	notification, notifyErr := batchNotifier.NotifyBatch(ctx, req)
+	wrappedErr := notifyErr
+	if notifyErr != nil {
+		wrappedErr = fmt.Errorf("notify batch %q run %q bundle %q: %w", batch, runID, req.BundleID, notifyErr)
+	}
+	path, saveErr := saveBatchNotificationArtifact(ctx, store, cfg, batch, runID, startedAt, req, notification, wrappedErr)
+	if saveErr != nil {
+		return nil, saveErr
+	}
+
+	batchResult := batchNotificationResult(req, notification, path)
+	if wrappedErr != nil {
+		batchResult.Status = "failed"
+		batchResult.Error = wrappedErr.Error()
+		return batchResult, wrappedErr
+	}
+	return batchResult, nil
+}
+
+func resolveBatchNotifier(cfg config.Config, notifier Notifier) (batchNotifier, error) {
+	if notifier != nil {
+		if batchNotifier, ok := notifier.(batchNotifier); ok {
+			return batchNotifier, nil
+		}
+		return nil, fmt.Errorf("batch distributor notifier is required")
+	}
+	return distributorNotifier{
+		client: distributoradapter.New(cfg.Notify.Distributor),
+	}, nil
+}
+
+func buildBatchNotificationRequest(cfg config.Config, batch BatchKind, runID string, startedAt time.Time, reports []BatchReportResult, planned []plannedBatchReport) (batchNotificationRequest, error) {
+	if len(reports) == 0 {
+		return batchNotificationRequest{}, fmt.Errorf("batch notification requires at least one report")
+	}
+
+	identity, err := renderBatchNotificationIdentity(cfg, batch, runID, startedAt)
+	if err != nil {
+		return batchNotificationRequest{}, err
+	}
+	if identity.PipelineID == "" {
+		return batchNotificationRequest{}, fmt.Errorf("batch notification pipeline id is required")
+	}
+	if identity.BundleID == "" {
+		return batchNotificationRequest{}, fmt.Errorf("batch notification bundle id is required")
+	}
+	if identity.IdempotencyKey == "" {
+		return batchNotificationRequest{}, fmt.Errorf("batch notification idempotency key is required for bundle %q", identity.BundleID)
+	}
+
+	plannedByRunID, err := plannedReportsByRunID(planned)
+	if err != nil {
+		return batchNotificationRequest{}, err
+	}
+
+	req := batchNotificationRequest{
+		Batch:          batch,
+		RunID:          runID,
+		PipelineID:     identity.PipelineID,
+		BundleID:       identity.BundleID,
+		IdempotencyKey: identity.IdempotencyKey,
+		CreatedAt:      startedAt,
+	}
+	seenBundlePaths := map[string]batchNotificationFile{}
+	for _, item := range reports {
+		plannedReport, ok := plannedByRunID[item.RunID]
+		if !ok {
+			return batchNotificationRequest{}, fmt.Errorf("batch notification report %q run %q has no matching planned report", item.ReportID, item.RunID)
+		}
+		if item.ReportID != plannedReport.Resolved.Definition.ID {
+			return batchNotificationRequest{}, fmt.Errorf("batch notification report %q run %q does not match planned report %q", item.ReportID, item.RunID, plannedReport.Resolved.Definition.ID)
+		}
+		if item.ReportPath == "" {
+			return batchNotificationRequest{}, fmt.Errorf("batch notification report %q run %q is missing managed report path", item.ReportID, item.RunID)
+		}
+
+		values, err := distributorTemplateValuesForReport(cfg, plannedReport.Resolved, item.RunID, plannedReport.OutputCopyName)
+		if err != nil {
+			return batchNotificationRequest{}, fmt.Errorf("batch notification report %q run %q source path %q: %w", item.ReportID, item.RunID, item.ReportPath, err)
+		}
+		bundlePaths, err := renderDistributorReportBundlePaths(cfg, plannedReport.Resolved, item.RunID, item.ReportPath, values)
+		if err != nil {
+			return batchNotificationRequest{}, err
+		}
+
+		included := BatchNotificationReport{
+			ReportID:    item.ReportID,
+			RunID:       item.RunID,
+			SourcePath:  item.ReportPath,
+			BundlePaths: append([]string(nil), bundlePaths...),
+		}
+		for _, bundlePath := range bundlePaths {
+			file := batchNotificationFile{
+				ReportID:   item.ReportID,
+				RunID:      item.RunID,
+				SourcePath: item.ReportPath,
+				BundlePath: bundlePath,
+			}
+			if previous, ok := seenBundlePaths[bundlePath]; ok {
+				return batchNotificationRequest{}, fmt.Errorf("batch notification duplicate bundle path %q for report %q run %q source path %q; already used by report %q run %q source path %q", bundlePath, item.ReportID, item.RunID, item.ReportPath, previous.ReportID, previous.RunID, previous.SourcePath)
+			}
+			seenBundlePaths[bundlePath] = file
+			req.Files = append(req.Files, file)
+		}
+		req.IncludedReports = append(req.IncludedReports, included)
+	}
+	if len(req.Files) == 0 {
+		return batchNotificationRequest{}, fmt.Errorf("batch notification requires at least one file mapping")
+	}
+	return req, nil
+}
+
+func plannedReportsByRunID(planned []plannedBatchReport) (map[string]plannedBatchReport, error) {
+	byRunID := make(map[string]plannedBatchReport, len(planned))
+	for _, item := range planned {
+		runID := item.Resolved.Metadata().RunID
+		if runID == "" {
+			return nil, fmt.Errorf("planned report %q has empty run id", item.Resolved.Definition.ID)
+		}
+		if previous, ok := byRunID[runID]; ok {
+			return nil, fmt.Errorf("planned reports %q and %q share run id %q", previous.Resolved.Definition.ID, item.Resolved.Definition.ID, runID)
+		}
+		byRunID[runID] = item
+	}
+	return byRunID, nil
+}
+
+func batchDistributorUploadRequest(req batchNotificationRequest) distributoradapter.UploadRequest {
+	files := make([]distributoradapter.UploadFile, 0, len(req.Files))
+	for _, file := range req.Files {
+		files = append(files, distributoradapter.UploadFile{
+			SourcePath: file.SourcePath,
+			BundlePath: file.BundlePath,
+		})
+	}
+	return distributoradapter.UploadRequest{
+		PipelineID:     req.PipelineID,
+		BundleID:       req.BundleID,
+		IdempotencyKey: req.IdempotencyKey,
+		Files:          files,
+		CreatedAt:      req.CreatedAt,
+	}
+}
+
+func batchNotificationResult(req batchNotificationRequest, result *NotificationResult, path string) *BatchNotificationResult {
+	notification := &BatchNotificationResult{
+		Status:          "unknown",
+		PipelineID:      req.PipelineID,
+		BundleID:        req.BundleID,
+		IdempotencyKey:  req.IdempotencyKey,
+		Path:            path,
+		IncludedReports: append([]BatchNotificationReport(nil), req.IncludedReports...),
+	}
+	if result != nil {
+		notification.Status = result.Status
+		notification.RunID = result.RunID
+		if result.PipelineID != "" {
+			notification.PipelineID = result.PipelineID
+		}
+		if result.BundleID != "" {
+			notification.BundleID = result.BundleID
+		}
+		if result.IdempotencyKey != "" {
+			notification.IdempotencyKey = result.IdempotencyKey
+		}
+		if result.Error != "" {
+			notification.Error = result.Error
+		}
+	}
+	if notification.Status == "" {
+		notification.Status = "unknown"
+	}
+	return notification
+}
+
+func failedBatchNotificationResult(req batchNotificationRequest, path string, err error) *BatchNotificationResult {
+	notification := batchNotificationResult(req, nil, path)
+	notification.Status = "failed"
+	if err != nil {
+		notification.Error = err.Error()
+	}
+	return notification
+}
+
+func saveBatchNotificationArtifact(ctx context.Context, store state.Store, cfg config.Config, batch BatchKind, runID string, startedAt time.Time, req batchNotificationRequest, result *NotificationResult, notifyErr error) (string, error) {
+	if store == nil {
+		return "", fmt.Errorf("state store is required")
+	}
+	location, err := timeutil.LoadLocation(cfg.WeatherAPI.Timezone)
+	if err != nil {
+		return "", fmt.Errorf("load batch notification timezone: %w", err)
+	}
+	artifact := state.BatchDistributorNotificationArtifact{
+		SchemaVersion:  state.BatchDistributorNotificationSchemaVersion,
+		Batch:          string(batch),
+		BatchRunID:     runID,
+		AttemptedAt:    time.Now(),
+		Endpoint:       cfg.Notify.Distributor.Endpoint,
+		PipelineID:     req.PipelineID,
+		BundleID:       req.BundleID,
+		IdempotencyKey: req.IdempotencyKey,
+		BundleCreated:  req.CreatedAt,
+		Reports:        batchNotificationReportArtifacts(req.IncludedReports),
+		Status:         "attempted",
+	}
+	if result != nil {
+		artifact.Status = result.Status
+		artifact.Upload = &state.DistributorUploadResult{
+			RunID:  result.RunID,
+			Status: result.UploadStatus,
+		}
+		if result.PipelineID != "" || !result.AcceptedAt.IsZero() || result.StartedAt != nil || result.FinishedAt != nil || len(result.Report) > 0 || result.Error != "" {
+			artifact.RunStatus = &state.DistributorRunStatus{
+				RunID:      result.RunID,
+				PipelineID: result.PipelineID,
+				Status:     result.Status,
+				AcceptedAt: result.AcceptedAt,
+				StartedAt:  result.StartedAt,
+				FinishedAt: result.FinishedAt,
+				Report:     append([]byte(nil), result.Report...),
+				Error:      result.Error,
+			}
+		}
+		artifact.StatusError = result.StatusError
+	}
+	if notifyErr != nil {
+		artifact.Status = "failed"
+		artifact.Error = notifyErr.Error()
+	}
+	if artifact.Status == "" {
+		artifact.Status = "unknown"
+	}
+	return store.SaveBatchDistributorNotification(ctx, state.BatchDistributorNotificationRef{
+		Batch:      string(batch),
+		BatchRunID: runID,
+		StartedAt:  startedAt,
+		Location:   location,
+	}, artifact)
+}
+
+func batchNotificationReportArtifacts(reports []BatchNotificationReport) []state.BatchDistributorNotificationReportArtifact {
+	if len(reports) == 0 {
+		return nil
+	}
+	artifacts := make([]state.BatchDistributorNotificationReportArtifact, 0, len(reports))
+	for _, item := range reports {
+		artifacts = append(artifacts, state.BatchDistributorNotificationReportArtifact{
+			ReportID:    item.ReportID,
+			RunID:       item.RunID,
+			SourcePath:  item.SourcePath,
+			BundlePaths: append([]string(nil), item.BundlePaths...),
+		})
+	}
+	return artifacts
+}
+
+func renderBatchNotificationIdentity(cfg config.Config, batch BatchKind, runID string, startedAt time.Time) (batchNotificationIdentity, error) {
+	values, err := batchNotificationTemplateValues(cfg, batch, runID, startedAt)
+	if err != nil {
+		return batchNotificationIdentity{}, err
+	}
+
+	bundleID, err := config.RenderDistributorBatchBundleID(cfg.Notify.Distributor.Batch.BundleIDTemplate, values)
+	if err != nil {
+		return batchNotificationIdentity{}, err
+	}
+	values.BundleID = bundleID
+
+	pipelineID, err := config.RenderDistributorBatchPipelineID(cfg.Notify.Distributor.Batch.PipelineIDTemplate, values)
+	if err != nil {
+		return batchNotificationIdentity{}, err
+	}
+	idempotencyKey, err := config.RenderDistributorBatchIdempotencyKey(cfg.Notify.Distributor.Batch.IdempotencyKeyTemplate, values)
+	if err != nil {
+		return batchNotificationIdentity{}, err
+	}
+
+	return batchNotificationIdentity{
+		PipelineID:     pipelineID,
+		BundleID:       bundleID,
+		IdempotencyKey: idempotencyKey,
+	}, nil
+}
+
+func batchNotificationTemplateValues(cfg config.Config, batch BatchKind, runID string, startedAt time.Time) (config.DistributorBatchTemplateValues, error) {
+	location, err := timeutil.LoadLocation(cfg.WeatherAPI.Timezone)
+	if err != nil {
+		return config.DistributorBatchTemplateValues{}, fmt.Errorf("load batch notification timezone: %w", err)
+	}
+	return config.DistributorBatchTemplateValues{
+		LocationID:       cfg.Location.ID,
+		Batch:            string(batch),
+		BatchRunID:       runID,
+		BatchStartedDate: startedAt.In(location).Format(timeutil.DateLayout),
+	}, nil
+}

internal/app/batch_plan.go

@@ -0,0 +1,139 @@
+package app
+
+import (
+	"fmt"
+	"time"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/collect"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
+)
+
+type plannedBatchReport struct {
+	Resolved       report.Resolved
+	OutputCopyName string
+}
+
+func planBatchRun(req BatchRequest, now time.Time, collection collect.Result) ([]plannedBatchReport, error) {
+	location, err := timeutil.LoadLocation(req.Config.WeatherAPI.Timezone)
+	if err != nil {
+		return nil, err
+	}
+	batch, err := report.BatchForCommandName(string(req.Batch))
+	if err != nil {
+		return nil, err
+	}
+	registry, err := reportRegistry(req.Config)
+	if err != nil {
+		return nil, err
+	}
+
+	resolveReq := report.ResolveRequest{
+		Now:      now,
+		Location: location,
+	}
+	var planned []plannedBatchReport
+	switch batch {
+	case report.Morning:
+		planned, err = appendPlannedReport(planned, registry, report.Today, resolveReq, "")
+		if err != nil {
+			return nil, err
+		}
+		planned, err = appendPlannedReport(planned, registry, report.Tomorrow, resolveReq, "")
+		if err != nil {
+			return nil, err
+		}
+	case report.Evening:
+		planned, err = appendPlannedReport(planned, registry, report.Tomorrow, resolveReq, "")
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, fmt.Errorf("unknown batch %q", batch)
+	}
+
+	var hourly *weatherdata.ForecastRun
+	if collection.Bundle != nil {
+		hourly = collection.Bundle.Hourly
+	}
+	for _, date := range eligibleDailyDates(hourly, now, location) {
+		dailyReq := resolveReq
+		dailyReq.Date = date
+		outputCopyName := "daily-" + date.In(location).Format(timeutil.DateLayout) + ".md"
+		planned, err = appendPlannedReport(planned, registry, report.Daily, dailyReq, outputCopyName)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return planned, nil
+}
+
+func appendPlannedReport(planned []plannedBatchReport, registry report.Registry, id report.ID, req report.ResolveRequest, outputCopyName string) ([]plannedBatchReport, error) {
+	resolved, err := registry.Resolve(id, req)
+	if err != nil {
+		return nil, err
+	}
+	return append(planned, plannedBatchReport{
+		Resolved:       resolved,
+		OutputCopyName: outputCopyName,
+	}), nil
+}
+
+func eligibleDailyDates(hourly *weatherdata.ForecastRun, now time.Time, location *time.Location) []time.Time {
+	if hourly == nil || location == nil || hourly.Product != "hourly" || len(hourly.Periods) == 0 {
+		return nil
+	}
+
+	hourlyStarts := make(map[time.Time]struct{}, len(hourly.Periods))
+	var maxLocalDate time.Time
+	for _, period := range hourly.Periods {
+		if !isHourlyPeriod(period) {
+			continue
+		}
+		start := period.StartTime
+		hourlyStarts[instantKey(start)] = struct{}{}
+		localDate := localDateStart(start, location)
+		if maxLocalDate.IsZero() || localDate.After(maxLocalDate) {
+			maxLocalDate = localDate
+		}
+	}
+	if len(hourlyStarts) == 0 || maxLocalDate.IsZero() {
+		return nil
+	}
+
+	startDate := localDateStart(now.In(location).AddDate(0, 0, 2), location)
+	var dates []time.Time
+	for candidate := startDate; !candidate.After(maxLocalDate); candidate = candidate.AddDate(0, 0, 1) {
+		if hasFullHourlyCoverage(candidate, location, hourlyStarts) {
+			dates = append(dates, candidate)
+		}
+	}
+	return dates
+}
+
+func isHourlyPeriod(period weatherdata.ForecastPeriod) bool {
+	if period.StartTime.IsZero() || period.EndTime.IsZero() {
+		return false
+	}
+	return period.EndTime.Equal(period.StartTime.Add(time.Hour))
+}
+
+func hasFullHourlyCoverage(date time.Time, location *time.Location, hourlyStarts map[time.Time]struct{}) bool {
+	day := timeutil.CivilDay(date, location)
+	for required := day.Start; required.Before(day.End); required = required.Add(time.Hour) {
+		if _, ok := hourlyStarts[instantKey(required)]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+func instantKey(value time.Time) time.Time {
+	return value.UTC()
+}
+
+func localDateStart(value time.Time, location *time.Location) time.Time {
+	local := value.In(location)
+	return time.Date(local.Year(), local.Month(), local.Day(), 0, 0, 0, 0, location)
+}

internal/app/batch_plan_test.go

@@ -0,0 +1,352 @@
+package app
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/collect"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
+)
+
+func TestPlanBatchRunMorningOrder(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	hourly := hourlyRun(fullDayPeriods(t, "2026-05-31", location)...)
+
+	planned, err := planBatchRun(BatchRequest{Config: planningConfig(), Batch: BatchMorning}, mustParse("2026-05-29T08:00:00-05:00"), collectionWithHourly(hourly))
+	if err != nil {
+		t.Fatalf("planBatchRun() error = %v", err)
+	}
+
+	assertPlannedReportIDs(t, planned, report.Today, report.Tomorrow, report.Daily)
+}
+
+func TestPlanBatchRunEveningOrder(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	hourly := hourlyRun(fullDayPeriods(t, "2026-05-31", location)...)
+
+	planned, err := planBatchRun(BatchRequest{Config: planningConfig(), Batch: BatchEvening}, mustParse("2026-05-29T18:00:00-05:00"), collectionWithHourly(hourly))
+	if err != nil {
+		t.Fatalf("planBatchRun() error = %v", err)
+	}
+
+	assertPlannedReportIDs(t, planned, report.Tomorrow, report.Daily)
+}
+
+func TestPlanBatchRunDynamicDailyDatesStartAfterTomorrow(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	periods := fullDayPeriods(t, "2026-05-30", location)
+	periods = append(periods, fullDayPeriods(t, "2026-05-31", location)...)
+	periods = append(periods, fullDayPeriods(t, "2026-06-01", location)...)
+
+	planned, err := planBatchRun(BatchRequest{Config: planningConfig(), Batch: BatchMorning}, mustParse("2026-05-29T08:00:00-05:00"), collectionWithHourly(hourlyRun(periods...)))
+	if err != nil {
+		t.Fatalf("planBatchRun() error = %v", err)
+	}
+
+	daily := plannedDailyReports(planned)
+	if len(daily) != 2 {
+		t.Fatalf("daily reports = %#v, want two future Daily reports", daily)
+	}
+	assertPlanningPeriod(t, daily[0].Resolved.ValidPeriod, "2026-05-31T00:00:00-05:00", "2026-06-01T00:00:00-05:00")
+	assertPlanningPeriod(t, daily[1].Resolved.ValidPeriod, "2026-06-01T00:00:00-05:00", "2026-06-02T00:00:00-05:00")
+}
+
+func TestPlanBatchRunMorningExcludesLegacyStaticReports(t *testing.T) {
+	planned, err := planBatchRun(BatchRequest{Config: planningConfig(), Batch: BatchMorning}, mustParse("2026-05-29T08:00:00-05:00"), collect.Result{Bundle: &weatherdata.Bundle{}})
+	if err != nil {
+		t.Fatalf("planBatchRun() error = %v", err)
+	}
+
+	for _, item := range planned {
+		if item.Resolved.Definition.ID == report.ThreeDay || item.Resolved.Definition.ID == report.Weekend {
+			t.Fatalf("morning plan includes %s, want no 3-Day or Weekend", item.Resolved.Definition.ID)
+		}
+	}
+}
+
+func TestPlanBatchRunDynamicDailyOutputCopyNames(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	hourly := hourlyRun(fullDayPeriods(t, "2026-05-31", location)...)
+
+	planned, err := planBatchRun(BatchRequest{Config: planningConfig(), Batch: BatchEvening}, mustParse("2026-05-29T18:00:00-05:00"), collectionWithHourly(hourly))
+	if err != nil {
+		t.Fatalf("planBatchRun() error = %v", err)
+	}
+
+	daily := plannedDailyReports(planned)
+	if len(daily) != 1 {
+		t.Fatalf("daily reports = %#v, want one Daily report", daily)
+	}
+	if daily[0].OutputCopyName != "daily-2026-05-31.md" {
+		t.Fatalf("OutputCopyName = %q, want date-qualified Daily name", daily[0].OutputCopyName)
+	}
+	if planned[0].OutputCopyName != "" {
+		t.Fatalf("Tomorrow OutputCopyName = %q, want definition batch output name to apply later", planned[0].OutputCopyName)
+	}
+}
+
+func TestPlanBatchRunRejectsUnknownBatch(t *testing.T) {
+	_, err := planBatchRun(BatchRequest{Config: planningConfig(), Batch: BatchKind("hourly")}, mustParse("2026-05-29T08:00:00-05:00"), collect.Result{Bundle: &weatherdata.Bundle{}})
+	if err == nil || !strings.Contains(err.Error(), `unknown batch command "hourly"`) {
+		t.Fatalf("planBatchRun() error = %v, want unknown batch command", err)
+	}
+}
+
+func TestEligibleDailyDatesRequiresFullOrdinaryLocalDay(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	hourly := hourlyRun(fullDayPeriods(t, "2026-05-31", location)...)
+
+	got := eligibleDailyDates(hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+	assertLocalDates(t, got, location, "2026-05-31")
+}
+
+func TestEligibleDailyDatesMatchesFixedOffsetStartInstants(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	hourly := hourlyRun(fixedOffsetPeriods(t, fullDayPeriods(t, "2026-05-31", location))...)
+
+	got := eligibleDailyDates(hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+	assertLocalDates(t, got, location, "2026-05-31")
+}
+
+func TestEligibleDailyDatesSkipsDayWithMissingRequiredHour(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	periods := fullDayPeriods(t, "2026-05-31", location)
+	periods = append(periods[:12], periods[13:]...)
+	hourly := hourlyRun(periods...)
+
+	got := eligibleDailyDates(hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+	assertLocalDates(t, got, location)
+}
+
+func TestEligibleDailyDatesSkipsPartialFinalDay(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	periods := fullDayPeriods(t, "2026-05-31", location)
+	periods = append(periods, partialDayPeriods(t, "2026-06-01", location, 12)...)
+	hourly := hourlyRun(periods...)
+
+	got := eligibleDailyDates(hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+	assertLocalDates(t, got, location, "2026-05-31")
+}
+
+func TestEligibleDailyDatesStartsAfterTomorrow(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	periods := fullDayPeriods(t, "2026-05-29", location)
+	periods = append(periods, fullDayPeriods(t, "2026-05-30", location)...)
+	periods = append(periods, fullDayPeriods(t, "2026-05-31", location)...)
+	hourly := hourlyRun(periods...)
+
+	got := eligibleDailyDates(hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+	assertLocalDates(t, got, location, "2026-05-31")
+}
+
+func TestEligibleDailyDatesReturnsMultipleFutureDatesInOrder(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	periods := fullDayPeriods(t, "2026-05-31", location)
+	periods = append(periods, fullDayPeriods(t, "2026-06-01", location)...)
+	hourly := hourlyRun(periods...)
+
+	got := eligibleDailyDates(hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+	assertLocalDates(t, got, location, "2026-05-31", "2026-06-01")
+}
+
+func TestEligibleDailyDatesIgnoresNonHourlyAndInvalidPeriods(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	day := timeutil.CivilDay(mustParseLocalDate(t, "2026-05-31", location), location)
+	periods := []weatherdata.ForecastPeriod{
+		{StartTime: day.Start, EndTime: day.Start.Add(2 * time.Hour)},
+		{StartTime: day.Start.Add(time.Hour), EndTime: day.Start.Add(time.Hour)},
+		{StartTime: time.Time{}, EndTime: day.Start.Add(3 * time.Hour)},
+	}
+	periods = append(periods, fullDayPeriods(t, "2026-06-01", location)...)
+	hourly := hourlyRun(periods...)
+
+	got := eligibleDailyDates(hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+	assertLocalDates(t, got, location, "2026-06-01")
+}
+
+func TestEligibleDailyDatesUsesDSTCivilDayInstants(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/New_York")
+	tests := []struct {
+		name string
+		now  string
+		date string
+	}{
+		{
+			name: "spring forward",
+			now:  "2026-03-06T08:00:00-05:00",
+			date: "2026-03-08",
+		},
+		{
+			name: "fall back",
+			now:  "2026-10-30T08:00:00-04:00",
+			date: "2026-11-01",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			hourly := hourlyRun(fullDayPeriods(t, tt.date, location)...)
+
+			got := eligibleDailyDates(hourly, mustParse(tt.now), location)
+			assertLocalDates(t, got, location, tt.date)
+		})
+	}
+}
+
+func TestEligibleDailyDatesReturnsNoneWithoutHourlyForecast(t *testing.T) {
+	location := mustLoadTestLocation(t, "America/Chicago")
+	fullDay := fullDayPeriods(t, "2026-05-31", location)
+
+	tests := []struct {
+		name   string
+		hourly *weatherdata.ForecastRun
+	}{
+		{name: "nil run"},
+		{name: "empty periods", hourly: hourlyRun()},
+		{name: "non-hourly product", hourly: forecastRun("narrative", fullDay...)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := eligibleDailyDates(tt.hourly, mustParse("2026-05-29T08:00:00-05:00"), location)
+			assertLocalDates(t, got, location)
+		})
+	}
+}
+
+func hourlyRun(periods ...weatherdata.ForecastPeriod) *weatherdata.ForecastRun {
+	return forecastRun("hourly", periods...)
+}
+
+func forecastRun(product string, periods ...weatherdata.ForecastPeriod) *weatherdata.ForecastRun {
+	return &weatherdata.ForecastRun{
+		Product: product,
+		Periods: periods,
+	}
+}
+
+func collectionWithHourly(hourly *weatherdata.ForecastRun) collect.Result {
+	return collect.Result{Bundle: &weatherdata.Bundle{Hourly: hourly}}
+}
+
+func planningConfig() config.Config {
+	cfg := config.Defaults()
+	cfg.WeatherAPI.Timezone = "America/Chicago"
+	return cfg
+}
+
+func assertPlannedReportIDs(t *testing.T, got []plannedBatchReport, want ...report.ID) {
+	t.Helper()
+	gotIDs := make([]string, 0, len(got))
+	for _, item := range got {
+		gotIDs = append(gotIDs, string(item.Resolved.Definition.ID))
+	}
+	wantIDs := make([]string, 0, len(want))
+	for _, id := range want {
+		wantIDs = append(wantIDs, string(id))
+	}
+	if strings.Join(gotIDs, ",") != strings.Join(wantIDs, ",") {
+		t.Fatalf("planned report IDs = [%s], want [%s]", strings.Join(gotIDs, ","), strings.Join(wantIDs, ","))
+	}
+}
+
+func plannedDailyReports(planned []plannedBatchReport) []plannedBatchReport {
+	var daily []plannedBatchReport
+	for _, item := range planned {
+		if item.Resolved.Definition.ID == report.Daily {
+			daily = append(daily, item)
+		}
+	}
+	return daily
+}
+
+func fullDayPeriods(t *testing.T, date string, location *time.Location) []weatherdata.ForecastPeriod {
+	t.Helper()
+	day := timeutil.CivilDay(mustParseLocalDate(t, date, location), location)
+	var periods []weatherdata.ForecastPeriod
+	for start := day.Start; start.Before(day.End); start = start.Add(time.Hour) {
+		periods = append(periods, weatherdata.ForecastPeriod{
+			StartTime: start,
+			EndTime:   start.Add(time.Hour),
+		})
+	}
+	return periods
+}
+
+func partialDayPeriods(t *testing.T, date string, location *time.Location, count int) []weatherdata.ForecastPeriod {
+	t.Helper()
+	periods := fullDayPeriods(t, date, location)
+	if count > len(periods) {
+		count = len(periods)
+	}
+	return periods[:count]
+}
+
+func fixedOffsetPeriods(t *testing.T, periods []weatherdata.ForecastPeriod) []weatherdata.ForecastPeriod {
+	t.Helper()
+	out := make([]weatherdata.ForecastPeriod, 0, len(periods))
+	for _, period := range periods {
+		start, err := time.Parse(time.RFC3339, period.StartTime.Format(time.RFC3339))
+		if err != nil {
+			t.Fatalf("parse fixed-offset start: %v", err)
+		}
+		end, err := time.Parse(time.RFC3339, period.EndTime.Format(time.RFC3339))
+		if err != nil {
+			t.Fatalf("parse fixed-offset end: %v", err)
+		}
+		out = append(out, weatherdata.ForecastPeriod{StartTime: start, EndTime: end})
+	}
+	return out
+}
+
+func assertLocalDates(t *testing.T, got []time.Time, location *time.Location, want ...string) {
+	t.Helper()
+	gotDates := make([]string, 0, len(got))
+	for _, date := range got {
+		gotDates = append(gotDates, date.In(location).Format(timeutil.DateLayout))
+	}
+	if strings.Join(gotDates, ",") != strings.Join(want, ",") {
+		t.Fatalf("eligibleDailyDates() = [%s], want [%s]", strings.Join(gotDates, ","), strings.Join(want, ","))
+	}
+	for _, date := range got {
+		day := timeutil.CivilDay(date, location)
+		if !date.Equal(day.Start) {
+			t.Fatalf("eligible date %s is not local civil day start %s", date, day.Start)
+		}
+	}
+}
+
+func assertPlanningPeriod(t *testing.T, period timeutil.Period, wantStart string, wantEnd string) {
+	t.Helper()
+	if !period.IsValid() {
+		t.Fatalf("period = %#v, want valid", period)
+	}
+	if got := period.Start.Format(time.RFC3339); got != wantStart {
+		t.Fatalf("Start = %s, want %s", got, wantStart)
+	}
+	if got := period.End.Format(time.RFC3339); got != wantEnd {
+		t.Fatalf("End = %s, want %s", got, wantEnd)
+	}
+}
+
+func mustLoadTestLocation(t *testing.T, name string) *time.Location {
+	t.Helper()
+	location, err := time.LoadLocation(name)
+	if err != nil {
+		t.Fatalf("LoadLocation(%q) error = %v", name, err)
+	}
+	return location
+}
+
+func mustParseLocalDate(t *testing.T, value string, location *time.Location) time.Time {
+	t.Helper()
+	parsed, err := timeutil.ParseLocalDate(value, location)
+	if err != nil {
+		t.Fatalf("ParseLocalDate(%q) error = %v", value, err)
+	}
+	return parsed
+}

internal/briefing/alert_digest_module.go

@@ -19,17 +19,21 @@ type AlertSummary struct {
 	Event        string `json:"event,omitempty"`
 	Headline     string `json:"headline,omitempty"`
 	Severity     string `json:"severity,omitempty"`
+	PeriodBegins string `json:"period_begins,omitempty"`
+	PeriodEnds   string `json:"period_ends,omitempty"`
+	Instruction  string `json:"instruction,omitempty"`
+	Description  string `json:"description,omitempty"`
 }
 
 func buildAlertDigestModule(ctx ModuleContext, _ any) (*module.Output, error) {
-	value := alertDigest(ctx.Collected, ctx.Derived.AlertOverlaps)
+	value := alertDigest(ctx.Collected, ctx.Derived.AlertOverlaps, ctx.Timezone)
 	if value == nil {
 		value = &AlertDigestModule{}
 	}
 	return &module.Output{ID: module.AlertDigest, StanzaName: "alert_digest", Value: *value}, nil
 }
 
-func alertDigest(collected facts.CollectedFacts, overlaps []forecast.AlertOverlap) *AlertDigestModule {
+func alertDigest(collected facts.CollectedFacts, overlaps []forecast.AlertOverlap, timezone string) *AlertDigestModule {
 	missing := sourceMissing(collected.SourceProvenance, "alerts")
 	if collected.Alerts == nil && !missing {
 		return nil
@@ -45,6 +49,10 @@ func alertDigest(collected facts.CollectedFacts, overlaps []forecast.AlertOverla
 			Event:        overlap.Event,
 			Headline:     overlap.Headline,
 			Severity:     overlap.Severity,
+			PeriodBegins: friendlyMonthDayTimeLabel(overlap.Period.Start, timezone),
+			PeriodEnds:   friendlyMonthDayTimeLabel(overlap.Period.End, timezone),
+			Instruction:  overlap.Instruction,
+			Description:  overlap.Description,
 		})
 	}
 	return value

internal/briefing/base_modules_test.go

@@ -89,6 +89,48 @@ func TestHourlyForecastModuleUsesValidPeriodHourlyPeriods(t *testing.T) {
 	}
 }
 
+func TestHourlyForecastPromptExportOmitsTemplateHelpers(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)
+	}
+	richText := mustMarshalModuleJSON(t, output.Value)
+	for _, field := range []string{"hour_label", "text_description_lower", "mention_precipitation"} {
+		if !strings.Contains(richText, field) {
+			t.Fatalf("rich hourly json = %s, want helper field %s", richText, field)
+		}
+	}
+
+	prompt := moduleDataPackageValue[HourlyForecastPromptExport](t, output)
+	if prompt.Product != "hourly" || prompt.SourceLocationID != "test-grid" || len(prompt.Periods) != 1 {
+		t.Fatalf("hourly prompt export = %#v, want hourly metadata and one period", prompt)
+	}
+	period := prompt.Periods[0]
+	if period.PeriodBegins != "2026-05-29 at 8:00 AM" || period.PeriodEnds != "2026-05-29 at 9:00 AM" || period.TextDescription != "Showers likely." {
+		t.Fatalf("hourly prompt period = %#v, want factual period fields", period)
+	}
+	if period.TemperatureF == nil || *period.TemperatureF != 76 || period.WindSpeedMph == nil || *period.WindSpeedMph != 14 || period.ProbabilityOfPrecipitationPercent == nil || *period.ProbabilityOfPrecipitationPercent != 70 {
+		t.Fatalf("hourly prompt period = %#v, want temperature, wind, and precip fields", period)
+	}
+	if period.WindDirection != "S" || period.RelativeHumidityPercent == nil || *period.RelativeHumidityPercent != 66 {
+		t.Fatalf("hourly prompt period = %#v, want wind direction and humidity", period)
+	}
+	promptText := mustMarshalModuleJSON(t, output.DataPackageValue())
+	for _, field := range []string{"period_begins", "period_ends", "text_description", "temperature_f", "wind_direction", "probability_of_precipitation_percent", "relative_humidity_percent"} {
+		if !strings.Contains(promptText, field) {
+			t.Fatalf("hourly prompt json = %s, want field %s", promptText, field)
+		}
+	}
+	for _, field := range []string{"hour_label", "text_description_lower", "mention_precipitation"} {
+		if strings.Contains(promptText, field) {
+			t.Fatalf("hourly prompt json = %s, want omitted helper field %s", promptText, field)
+		}
+	}
+}
+
 func TestHourlyForecastPrecipMentionThreshold(t *testing.T) {
 	periods := []weatherdata.ForecastPeriod{
 		{StartTime: mustParseModuleTime("2026-05-29T08:00:00-05:00"), ProbabilityOfPrecipitationPercent: floatPtr(19)},
@@ -202,7 +244,7 @@ func TestMetadataModuleUsesPromptSafeSourceWarningSummary(t *testing.T) {
 		t.Fatalf("BuildModule() error = %v", err)
 	}
 	value := moduleValue[MetadataModule](t, output)
-	if value.RunID == "" || value.ReportID != report.DailyToday || value.PromptID != "weather.daily_report" {
+	if value.RunID == "" || value.ReportID != report.Daily || value.PromptID != "weather.daily_generated_text" {
 		t.Fatalf("metadata = %#v, want report identity", value)
 	}
 	if value.Location == nil || value.Location.Name != "Brentwood" {
@@ -260,6 +302,44 @@ func TestCurrentConditionsModuleUsesSnakeCaseUnitFields(t *testing.T) {
 	}
 }
 
+func TestCurrentConditionsPromptExportOmitsTemplateHelpers(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := testModuleContext()
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.CurrentConditions})
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	richText := mustMarshalModuleJSON(t, output.Value)
+	for _, field := range []string{"condition_text_lower", "wind_direction_text"} {
+		if !strings.Contains(richText, field) {
+			t.Fatalf("rich current conditions json = %s, want helper field %s", richText, field)
+		}
+	}
+
+	prompt := moduleDataPackageValue[CurrentConditionsPromptExport](t, output)
+	if prompt.ConditionText != "Partly cloudy" || prompt.TemperatureF == nil || *prompt.TemperatureF != 74 {
+		t.Fatalf("current prompt export = %#v, want condition text and temperature", prompt)
+	}
+	if prompt.ApparentTemperatureF == nil || *prompt.ApparentTemperatureF != 76 || prompt.RelativeHumidityPercent == nil || *prompt.RelativeHumidityPercent != 71 || prompt.WindSpeedMph == nil || *prompt.WindSpeedMph != 8 {
+		t.Fatalf("current prompt export = %#v, want apparent temperature, humidity, and wind speed", prompt)
+	}
+	if prompt.WindDirection != "S" {
+		t.Fatalf("current prompt wind direction = %q, want S", prompt.WindDirection)
+	}
+	promptText := mustMarshalModuleJSON(t, output.DataPackageValue())
+	for _, field := range []string{"condition_text", "temperature_f", "apparent_temperature_f", "relative_humidity_percent", "wind_speed_mph", "wind_direction"} {
+		if !strings.Contains(promptText, field) {
+			t.Fatalf("current prompt json = %s, want field %s", promptText, field)
+		}
+	}
+	for _, field := range []string{"condition_text_lower", "wind_direction_text"} {
+		if strings.Contains(promptText, field) {
+			t.Fatalf("current prompt json = %s, want omitted helper field %s", promptText, field)
+		}
+	}
+}
+
 func TestAlertDigestDistinguishesCheckedEmptyAndMissing(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := testModuleContext()
@@ -287,6 +367,39 @@ func TestAlertDigestDistinguishesCheckedEmptyAndMissing(t *testing.T) {
 	}
 }
 
+func TestAlertDigestIncludesPeriodAndGuidance(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := testModuleContext()
+	ctx.Collected.Alerts = &weatherdata.AlertRun{Alerts: []json.RawMessage{json.RawMessage(`{"event":"Wind Advisory"}`)}}
+	ctx.Derived.AlertOverlaps = []forecast.AlertOverlap{{
+		Event:       "Wind Advisory",
+		Headline:    "Wind Advisory until 8 PM",
+		Severity:    "Moderate",
+		Period:      timeutil.Period{Start: mustParseModuleTime("2026-06-17T18:00:00Z"), End: mustParseModuleTime("2026-06-18T01:00:00Z")},
+		Instruction: "Secure outdoor objects.",
+		Description: "Gusty winds may blow around unsecured objects.",
+	}}
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.AlertDigest})
+	if err != nil {
+		t.Fatalf("BuildModule(alert digest) error = %v", err)
+	}
+	value := moduleValue[AlertDigestModule](t, output)
+	if len(value.Relevant) != 1 {
+		t.Fatalf("Relevant length = %d, want 1", len(value.Relevant))
+	}
+	alert := value.Relevant[0]
+	if alert.Event != "Wind Advisory" || alert.Headline != "Wind Advisory until 8 PM" || alert.Severity != "Moderate" {
+		t.Fatalf("alert identity = %#v, want preserved event/headline/severity", alert)
+	}
+	if alert.PeriodBegins != "June 17 at 1:00 PM" || alert.PeriodEnds != "June 17 at 8:00 PM" {
+		t.Fatalf("alert period = %q/%q, want friendly local labels", alert.PeriodBegins, alert.PeriodEnds)
+	}
+	if alert.Instruction != "Secure outdoor objects." || alert.Description != "Gusty winds may blow around unsecured objects." {
+		t.Fatalf("alert guidance = %#v, want instruction and description preserved", alert)
+	}
+}
+
 func TestBaseModulesOmitMissingOptionalOutputs(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := testModuleContext()
@@ -393,9 +506,37 @@ func TestAreaForecastDiscussionModuleUsesHourlyDefaultSections(t *testing.T) {
 	}
 }
 
+func TestAreaForecastDiscussionModuleUsesDailyDefaultSections(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := testModuleContext()
+	ctx.Resolved.Definition = report.DefaultRegistry().MustLookup(report.Daily)
+	var item module.ConfigItem
+	for _, candidate := range ctx.Resolved.Definition.Modules {
+		if candidate.ID == module.AreaForecastDiscussion {
+			item = candidate
+			break
+		}
+	}
+	if item.ID == "" {
+		t.Fatal("daily default modules missing area_forecast_discussion")
+	}
+
+	output, err := registry.BuildModule(ctx, item)
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	afd := moduleValue[AreaForecastDiscussionModule](t, output)
+	if afd.LongTerm != "Periodic rain chances continue." {
+		t.Fatalf("LongTerm = %q, want selected long term section", afd.LongTerm)
+	}
+	if afd.Product != "" || len(afd.KeyMessages) != 0 || afd.ShortTerm != "" {
+		t.Fatalf("AFD = %#v, want only long term section", afd)
+	}
+}
+
 func testModuleContext() ModuleContext {
 	generatedAt := mustParseModuleTime("2026-05-29T08:00:00-05:00")
-	definition := report.DefaultRegistry().MustLookup(report.DailyToday)
+	definition := report.DefaultRegistry().MustLookup(report.Daily)
 	resolved := report.Resolved{
 		Definition:  definition,
 		GeneratedAt: generatedAt,
@@ -563,6 +704,28 @@ func moduleValue[T any](t *testing.T, output *module.Output) T {
 	return value
 }
 
+func moduleDataPackageValue[T any](t *testing.T, output *module.Output) T {
+	t.Helper()
+	var value T
+	data, err := json.Marshal(output.DataPackageValue())
+	if err != nil {
+		t.Fatalf("marshal module data package value: %v", err)
+	}
+	if err := json.Unmarshal(data, &value); err != nil {
+		t.Fatalf("decode module data package value: %v", err)
+	}
+	return value
+}
+
+func mustMarshalModuleJSON(t *testing.T, value any) string {
+	t.Helper()
+	data, err := json.Marshal(value)
+	if err != nil {
+		t.Fatalf("marshal module value: %v", err)
+	}
+	return string(data)
+}
+
 func mustParseModuleTime(value string) time.Time {
 	parsed, err := time.Parse(time.RFC3339, value)
 	if err != nil {

internal/briefing/current_conditions_module.go

@@ -23,6 +23,21 @@ type CurrentConditionsModule struct {
 	WindDirectionText       string `json:"wind_direction_text,omitempty"`
 }
 
+type CurrentConditionsPromptExport struct {
+	ConditionText           string `json:"condition_text,omitempty"`
+	IsDay                   *bool  `json:"is_day,omitempty"`
+	TemperatureC            *int   `json:"temperature_c,omitempty"`
+	TemperatureF            *int   `json:"temperature_f,omitempty"`
+	ApparentTemperatureC    *int   `json:"apparent_temperature_c,omitempty"`
+	ApparentTemperatureF    *int   `json:"apparent_temperature_f,omitempty"`
+	DewpointC               *int   `json:"dewpoint_c,omitempty"`
+	DewpointF               *int   `json:"dewpoint_f,omitempty"`
+	RelativeHumidityPercent *int   `json:"relative_humidity_percent,omitempty"`
+	WindSpeedKmh            *int   `json:"wind_speed_kmh,omitempty"`
+	WindSpeedMph            *int   `json:"wind_speed_mph,omitempty"`
+	WindDirection           string `json:"wind_direction,omitempty"`
+}
+
 func buildCurrentConditionsModule(ctx ModuleContext, _ any) (*module.Output, error) {
 	current := ctx.Collected.Current
 	if current == nil {
@@ -50,6 +65,27 @@ func buildCurrentConditionsModule(ctx ModuleContext, _ any) (*module.Output, err
 	return &module.Output{ID: module.CurrentConditions, StanzaName: "current_conditions", Value: value}, nil
 }
 
+func exportCurrentConditionsPromptValue(value any) (any, error) {
+	rich, ok := value.(CurrentConditionsModule)
+	if !ok {
+		return nil, unexpectedPromptExportValue(value, CurrentConditionsModule{})
+	}
+	return CurrentConditionsPromptExport{
+		ConditionText:           rich.ConditionText,
+		IsDay:                   copyBool(rich.IsDay),
+		TemperatureC:            copyInt(rich.TemperatureC),
+		TemperatureF:            copyInt(rich.TemperatureF),
+		ApparentTemperatureC:    copyInt(rich.ApparentTemperatureC),
+		ApparentTemperatureF:    copyInt(rich.ApparentTemperatureF),
+		DewpointC:               copyInt(rich.DewpointC),
+		DewpointF:               copyInt(rich.DewpointF),
+		RelativeHumidityPercent: copyInt(rich.RelativeHumidityPercent),
+		WindSpeedKmh:            copyInt(rich.WindSpeedKmh),
+		WindSpeedMph:            copyInt(rich.WindSpeedMph),
+		WindDirection:           rich.WindDirection,
+	}, nil
+}
+
 func (v CurrentConditionsModule) isEmpty() bool {
 	return v.ConditionText == "" &&
 		v.ConditionTextLower == "" &&

internal/briefing/daily_planning_module.go

@@ -0,0 +1,24 @@
+package briefing
+
+import "gitea.maximumdirect.net/eric/weatherreporter/internal/module"
+
+type DailyPlanningModule struct {
+	MorningReadiness             []string `json:"morning_readiness,omitempty"`
+	CommuteSchoolWorkdayConcerns []string `json:"commute_school_workday_concerns,omitempty"`
+	OvernightChangeWatch         []string `json:"overnight_change_watch,omitempty"`
+}
+
+func buildDailyPlanningModule(ctx ModuleContext, _ any) (*module.Output, error) {
+	summary := ctx.Derived.FirstDailySummary()
+	if summary == nil {
+		return &module.Output{ID: module.DailyPlanning, StanzaName: "daily_planning", Value: DailyPlanningModule{}}, nil
+	}
+	planning := buildMorningCommuteOvernightPlanning(summary)
+	value := DailyPlanningModule{}
+	if planning != nil {
+		value.MorningReadiness = append([]string(nil), planning.MorningReadiness...)
+		value.CommuteSchoolWorkdayConcerns = append([]string(nil), planning.CommuteSchoolWorkdayConcerns...)
+		value.OvernightChangeWatch = append([]string(nil), planning.OvernightChangeWatch...)
+	}
+	return &module.Output{ID: module.DailyPlanning, StanzaName: "daily_planning", Value: value}, nil
+}

internal/briefing/derived_daypart_summaries_module.go

@@ -44,6 +44,34 @@ type DerivedDaypartSummaryModule struct {
 	RelevantAlertCount       int      `json:"relevant_alert_count,omitempty"`
 }
 
+type DerivedDaypartSummaryPromptExport struct {
+	Date                     string   `json:"date,omitempty"`
+	DisplayName              string   `json:"display_name,omitempty"`
+	PeriodBegins             string   `json:"period_begins,omitempty"`
+	PeriodEnds               string   `json:"period_ends,omitempty"`
+	TempRangeF               string   `json:"temp_range_f,omitempty"`
+	ApparentTempRangeF       string   `json:"apparent_temp_range_f,omitempty"`
+	MaxPopPercent            *int     `json:"max_pop_percent,omitempty"`
+	MaxPopTime               string   `json:"max_pop_time,omitempty"`
+	MentionPrecipitation     bool     `json:"mention_precipitation,omitempty"`
+	MaxWindGustMph           *int     `json:"max_wind_gust_mph,omitempty"`
+	MaxWindGustTime          string   `json:"max_wind_gust_time,omitempty"`
+	DominantCondition        string   `json:"dominant_condition,omitempty"`
+	TemperatureTrend         string   `json:"temperature_trend,omitempty"`
+	TemperatureStartPhraseF  string   `json:"temperature_start_phrase_f,omitempty"`
+	TemperatureEndPhraseF    string   `json:"temperature_end_phrase_f,omitempty"`
+	TemperaturePeakPhraseF   string   `json:"temperature_peak_phrase_f,omitempty"`
+	TemperatureSteadyPhraseF string   `json:"temperature_steady_phrase_f,omitempty"`
+	NotableConditions        []string `json:"notable_conditions,omitempty"`
+	Snow                     bool     `json:"snow,omitempty"`
+	Ice                      bool     `json:"ice,omitempty"`
+	Fog                      bool     `json:"fog,omitempty"`
+	Heat                     bool     `json:"heat,omitempty"`
+	Cold                     bool     `json:"cold,omitempty"`
+	Wind                     bool     `json:"wind,omitempty"`
+	RelevantAlertCount       int      `json:"relevant_alert_count,omitempty"`
+}
+
 func buildDerivedDaypartSummariesModule(ctx ModuleContext, _ any) (*module.Output, error) {
 	if len(ctx.Derived.DaypartSummaries) == 0 {
 		return nil, fmt.Errorf("daypart summary facts are required")
@@ -57,6 +85,52 @@ func buildDerivedDaypartSummariesModule(ctx ModuleContext, _ any) (*module.Outpu
 	return &module.Output{ID: module.DerivedDaypartSummaries, StanzaName: "derived_daypart_summaries", Value: value}, nil
 }
 
+func exportDerivedDaypartSummariesPromptValue(value any) (any, error) {
+	rich, ok := value.(map[string]DerivedDaypartSummaryModule)
+	if !ok {
+		return nil, unexpectedPromptExportValue(value, map[string]DerivedDaypartSummaryModule{})
+	}
+	out := make(map[string]DerivedDaypartSummaryPromptExport, len(rich))
+	for key, daypart := range rich {
+		out[key] = derivedDaypartSummaryPromptValue(daypart)
+	}
+	return out, nil
+}
+
+func derivedDaypartSummaryPromptValue(rich DerivedDaypartSummaryModule) DerivedDaypartSummaryPromptExport {
+	maxPopTime := rich.MaxPopTime
+	if rich.MaxPopTimeLabel != "" {
+		maxPopTime = rich.MaxPopTimeLabel
+	}
+	return DerivedDaypartSummaryPromptExport{
+		Date:                     rich.Date,
+		DisplayName:              rich.DisplayName,
+		PeriodBegins:             rich.PeriodBegins,
+		PeriodEnds:               rich.PeriodEnds,
+		TempRangeF:               rich.TempRangeF,
+		ApparentTempRangeF:       rich.ApparentTempRangeF,
+		MaxPopPercent:            copyInt(rich.MaxPopPercent),
+		MaxPopTime:               maxPopTime,
+		MentionPrecipitation:     rich.MentionPrecipitation,
+		MaxWindGustMph:           copyInt(rich.MaxWindGustMph),
+		MaxWindGustTime:          rich.MaxWindGustTime,
+		DominantCondition:        rich.DominantCondition,
+		TemperatureTrend:         rich.TemperatureTrend,
+		TemperatureStartPhraseF:  rich.TemperatureStartPhraseF,
+		TemperatureEndPhraseF:    rich.TemperatureEndPhraseF,
+		TemperaturePeakPhraseF:   rich.TemperaturePeakPhraseF,
+		TemperatureSteadyPhraseF: rich.TemperatureSteadyPhraseF,
+		NotableConditions:        append([]string(nil), rich.NotableConditions...),
+		Snow:                     rich.Snow,
+		Ice:                      rich.Ice,
+		Fog:                      rich.Fog,
+		Heat:                     rich.Heat,
+		Cold:                     rich.Cold,
+		Wind:                     rich.Wind,
+		RelevantAlertCount:       rich.RelevantAlertCount,
+	}
+}
+
 func derivedDaypartSummaryValue(daypart forecast.DaypartSummary, timezone string) DerivedDaypartSummaryModule {
 	temperature := daypartTemperatureDisplay(daypart)
 	value := DerivedDaypartSummaryModule{

internal/briefing/derived_modules_test.go

@@ -16,7 +16,7 @@ import (
 
 func TestDerivedDailySummaryModulePackagesOrdinaryForecast(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	ctx := derivedModuleContext(report.DailyToday)
+	ctx := derivedModuleContext(report.Daily)
 
 	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DerivedDailySummary})
 	if err != nil {
@@ -67,7 +67,7 @@ func TestDerivedDailySummaryModulePackagesOrdinaryForecast(t *testing.T) {
 
 func TestDerivedDailySummaryModuleFallsBackWithoutNarrativeFacts(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	ctx := derivedModuleContext(report.DailyToday)
+	ctx := derivedModuleContext(report.Daily)
 	ctx.Derived.DailySummaries[0].NarrativePeriods = nil
 
 	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DerivedDailySummary})
@@ -89,7 +89,7 @@ func TestDerivedDailySummaryModuleFallsBackWithoutNarrativeFacts(t *testing.T) {
 
 func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	ctx := derivedModuleContext(report.DailyToday)
+	ctx := derivedModuleContext(report.Daily)
 
 	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.PrecipTiming})
 	if err != nil {
@@ -105,9 +105,15 @@ func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {
 	if rainy.PrecipitationWindows[0].PeriodBegins != "2026-05-29 at 8:00 AM" || rainy.PrecipitationWindows[0].PeriodBeginsHourLabel != "8:00 AM" || rainy.PrecipitationWindows[0].PeriodEnds != "2026-05-29 at 9:00 AM" || rainy.PrecipitationWindows[0].PeriodEndsHourLabel != "9:00 AM" || rainy.PrecipitationWindows[0].MaxPopPercent == nil || *rainy.PrecipitationWindows[0].MaxPopPercent != 60 || rainy.PrecipitationWindows[0].MaxPopHourLabel != "8:00 AM" {
 		t.Fatalf("first precipitation window = %#v, want 8-9 AM at 60%%", rainy.PrecipitationWindows[0])
 	}
+	if rainy.PrecipitationWindows[0].PrecipitationType != "showers" || rainy.PrecipitationWindows[0].ExpectationPhrase != "Showers likely." {
+		t.Fatalf("first precipitation window phrase = %#v, want showers likely", rainy.PrecipitationWindows[0])
+	}
 	if rainy.PrecipitationWindows[1].PeriodBegins != "2026-05-29 at 12:00 PM" || rainy.PrecipitationWindows[1].PeriodBeginsHourLabel != "12:00 PM" || rainy.PrecipitationWindows[1].PeriodEnds != "2026-05-29 at 2:00 PM" || rainy.PrecipitationWindows[1].PeriodEndsHourLabel != "2:00 PM" || rainy.PrecipitationWindows[1].MaxPopPercent == nil || *rainy.PrecipitationWindows[1].MaxPopPercent != 80 || rainy.PrecipitationWindows[1].MaxPopHourLabel != "12:00 PM" {
 		t.Fatalf("second precipitation window = %#v, want noon-2 PM at 80%%", rainy.PrecipitationWindows[1])
 	}
+	if rainy.PrecipitationWindows[1].PrecipitationType != "showers and thunderstorms" || rainy.PrecipitationWindows[1].ExpectationPhrase != "Expect showers and thunderstorms." {
+		t.Fatalf("second precipitation window phrase = %#v, want expect showers and thunderstorms", rainy.PrecipitationWindows[1])
+	}
 	data, err := json.Marshal(output.Value)
 	if err != nil {
 		t.Fatalf("marshal precip timing: %v", err)
@@ -115,6 +121,9 @@ func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {
 	if !strings.Contains(string(data), "precipitation_windows") || !strings.Contains(string(data), "probability_threshold") || !strings.Contains(string(data), "period_begins_hour_label") || !strings.Contains(string(data), "max_pop_hour_label") {
 		t.Fatalf("precip timing json = %s, want threshold and windows", string(data))
 	}
+	if !strings.Contains(string(data), "precipitation_type") || !strings.Contains(string(data), "expectation_phrase") {
+		t.Fatalf("precip timing json = %s, want precipitation type and expectation phrase", string(data))
+	}
 	if strings.Contains(string(data), `"start"`) || strings.Contains(string(data), `"end"`) {
 		t.Fatalf("precip timing json = %s, want period_begins/period_ends instead of start/end", string(data))
 	}
@@ -136,6 +145,100 @@ func TestPrecipTimingModuleHandlesRainyAndDryForecasts(t *testing.T) {
 	}
 }
 
+func TestPrecipTimingModuleBuildsExpectationPhrases(t *testing.T) {
+	now := mustParseModuleTime("2026-05-29T08:00:00-05:00")
+	tests := []struct {
+		name         string
+		maxPop       float64
+		descriptions []string
+		wantType     string
+		wantPhrase   string
+	}{
+		{
+			name:         "chance lower bound",
+			maxPop:       40,
+			descriptions: []string{"Scattered showers"},
+			wantType:     "showers",
+			wantPhrase:   "Chance of showers.",
+		},
+		{
+			name:         "chance upper bound",
+			maxPop:       49,
+			descriptions: []string{"Rain possible"},
+			wantType:     "rain",
+			wantPhrase:   "Chance of rain.",
+		},
+		{
+			name:         "likely lower bound",
+			maxPop:       50,
+			descriptions: []string{"Drizzle"},
+			wantType:     "drizzle",
+			wantPhrase:   "Drizzle likely.",
+		},
+		{
+			name:         "likely upper bound",
+			maxPop:       69,
+			descriptions: []string{"Freezing rain"},
+			wantType:     "freezing rain",
+			wantPhrase:   "Freezing rain likely.",
+		},
+		{
+			name:         "expect lower bound",
+			maxPop:       70,
+			descriptions: []string{"Snow"},
+			wantType:     "snow",
+			wantPhrase:   "Expect snow.",
+		},
+		{
+			name:         "showers and thunderstorms preferred",
+			maxPop:       100,
+			descriptions: []string{"Showers likely", "Thunderstorms possible"},
+			wantType:     "showers and thunderstorms",
+			wantPhrase:   "Expect showers and thunderstorms.",
+		},
+		{
+			name:         "thunderstorms only",
+			maxPop:       80,
+			descriptions: []string{"Thunderstorms"},
+			wantType:     "thunderstorms",
+			wantPhrase:   "Expect thunderstorms.",
+		},
+		{
+			name:         "unknown fallback",
+			maxPop:       95,
+			descriptions: []string{"Unsettled conditions"},
+			wantType:     "precipitation",
+			wantPhrase:   "Expect precipitation.",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			value := precipTimingValue(forecast.PrecipTiming{
+				ProbabilityThreshold: forecast.DefaultPrecipWindowProbabilityThreshold,
+				PrecipitationWindows: []forecast.PrecipitationWindow{
+					{
+						Start: now,
+						MaxPrecipitationProbability: forecast.TimedValue{
+							Value: tt.maxPop,
+							Time:  now,
+						},
+						ProbabilityThreshold: forecast.DefaultPrecipWindowProbabilityThreshold,
+						TextDescriptions:     tt.descriptions,
+					},
+				},
+			}, "America/Chicago")
+			if len(value.PrecipitationWindows) != 1 {
+				t.Fatalf("PrecipitationWindows = %#v, want one window", value.PrecipitationWindows)
+			}
+			window := value.PrecipitationWindows[0]
+			if window.PrecipitationType != tt.wantType || window.ExpectationPhrase != tt.wantPhrase {
+				t.Fatalf("window = %#v, want type %q and phrase %q", window, tt.wantType, tt.wantPhrase)
+			}
+		})
+	}
+}
+
 func TestPrecipTimingModuleUsesDerivedTimingWithoutDaypartSummaries(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := derivedModuleContext(report.Hourly)
@@ -154,7 +257,7 @@ func TestPrecipTimingModuleUsesDerivedTimingWithoutDaypartSummaries(t *testing.T
 
 func TestDerivedDaypartSummariesExposeConfiguredKeysAndHazards(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	ctx := derivedModuleContext(report.DailyToday)
+	ctx := derivedModuleContext(report.Daily)
 
 	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DerivedDaypartSummaries})
 	if err != nil {
@@ -201,6 +304,126 @@ func TestDerivedDaypartSummariesExposeConfiguredKeysAndHazards(t *testing.T) {
 	}
 }
 
+func TestDerivedDaypartSummariesPromptExportOmitsTemplateHelpers(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := derivedModuleContext(report.Daily)
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DerivedDaypartSummaries})
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	richText := mustMarshalModuleJSON(t, output.Value)
+	for _, field := range []string{"temperature_phrase_f", "dominant_condition_lower", "dominant_condition_display", "max_pop_time_label"} {
+		if !strings.Contains(richText, field) {
+			t.Fatalf("rich daypart json = %s, want helper field %s", richText, field)
+		}
+	}
+
+	prompt := moduleDataPackageValue[map[string]DerivedDaypartSummaryPromptExport](t, output)
+	morning, ok := prompt["morning"]
+	if !ok {
+		t.Fatalf("daypart prompt keys = %#v, want morning", prompt)
+	}
+	if morning.Date != "2026-05-29" || morning.DisplayName != "Morning" || morning.PeriodBegins != "2026-05-29 at 6:00 AM" || morning.PeriodEnds != "2026-05-29 at 12:00 PM" {
+		t.Fatalf("morning prompt period = %#v, want date/display/period labels", morning)
+	}
+	if morning.TempRangeF != "58" || morning.MaxPopPercent == nil || *morning.MaxPopPercent != 60 || morning.MaxPopTime != "6:00 AM" || !morning.MentionPrecipitation {
+		t.Fatalf("morning prompt precip/temp = %#v, want factual prompt fields with friendly max pop time", morning)
+	}
+	if morning.DominantCondition != "Showers" || morning.TemperatureTrend != "steady" || morning.TemperatureSteadyPhraseF != "upper 50s" {
+		t.Fatalf("morning prompt condition/trend = %#v, want condition and trend fields", morning)
+	}
+	if len(morning.NotableConditions) == 0 || morning.NotableConditions[0] != "Showers" {
+		t.Fatalf("morning prompt notable conditions = %#v, want copied conditions", morning.NotableConditions)
+	}
+	afternoon := prompt["afternoon"]
+	if !afternoon.Heat || !afternoon.Wind || afternoon.MaxWindGustMph == nil || *afternoon.MaxWindGustMph != 42 || afternoon.RelevantAlertCount != 1 {
+		t.Fatalf("afternoon prompt = %#v, want hazard, wind, and alert fields", afternoon)
+	}
+
+	promptText := mustMarshalModuleJSON(t, output.DataPackageValue())
+	for _, field := range []string{"date", "display_name", "period_begins", "period_ends", "temp_range_f", "max_pop_percent", "max_pop_time", "mention_precipitation", "max_wind_gust_mph", "dominant_condition", "temperature_trend", "temperature_steady_phrase_f", "notable_conditions", "relevant_alert_count"} {
+		if !strings.Contains(promptText, field) {
+			t.Fatalf("daypart prompt json = %s, want field %s", promptText, field)
+		}
+	}
+	for _, field := range []string{"temperature_phrase_f", "dominant_condition_lower", "dominant_condition_display", "max_pop_time_label"} {
+		if strings.Contains(promptText, field) {
+			t.Fatalf("daypart prompt json = %s, want omitted helper field %s", promptText, field)
+		}
+	}
+}
+
+func TestDerivedDaypartPromptExportTemperatureTrends(t *testing.T) {
+	tests := []struct {
+		name       string
+		temps      []float64
+		wantTrend  string
+		wantStart  string
+		wantEnd    string
+		wantPeak   string
+		wantSteady string
+	}{
+		{
+			name:      "rising",
+			temps:     []float64{58, 68},
+			wantTrend: "rising",
+			wantStart: "upper 50s",
+			wantEnd:   "upper 60s",
+		},
+		{
+			name:      "falling",
+			temps:     []float64{65, 58},
+			wantTrend: "falling",
+			wantStart: "mid 60s",
+			wantEnd:   "upper 50s",
+		},
+		{
+			name:      "peaking",
+			temps:     []float64{62, 78, 65},
+			wantTrend: "peaking",
+			wantPeak:  "upper 70s",
+		},
+		{
+			name:       "steady",
+			temps:      []float64{77, 78},
+			wantTrend:  "steady",
+			wantSteady: "upper 70s",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			rich := derivedDaypartSummaryValue(derivedDaypartWithTemperatures(test.name, "2026-05-29T12:00:00-05:00", "sunny", test.temps...), "America/Chicago")
+			prompt := derivedDaypartSummaryPromptValue(rich)
+			if prompt.TemperatureTrend != test.wantTrend ||
+				prompt.TemperatureStartPhraseF != test.wantStart ||
+				prompt.TemperatureEndPhraseF != test.wantEnd ||
+				prompt.TemperaturePeakPhraseF != test.wantPeak ||
+				prompt.TemperatureSteadyPhraseF != test.wantSteady {
+				t.Fatalf("prompt temperature presentation = %#v", prompt)
+			}
+		})
+	}
+}
+
+func TestDerivedDaypartPromptExportMaxPopTimeFallback(t *testing.T) {
+	withLabel := derivedDaypartSummaryPromptValue(DerivedDaypartSummaryModule{
+		MaxPopTime:      "6 AM",
+		MaxPopTimeLabel: "6:00 AM",
+	})
+	if withLabel.MaxPopTime != "6:00 AM" {
+		t.Fatalf("MaxPopTime with label = %q, want friendly label", withLabel.MaxPopTime)
+	}
+
+	withoutLabel := derivedDaypartSummaryPromptValue(DerivedDaypartSummaryModule{
+		MaxPopTime: "6 AM",
+	})
+	if withoutLabel.MaxPopTime != "6 AM" {
+		t.Fatalf("MaxPopTime without label = %q, want fallback time", withoutLabel.MaxPopTime)
+	}
+}
+
 func TestDerivedDaypartTemperaturePresentationFields(t *testing.T) {
 	tests := []struct {
 		name       string
@@ -337,9 +560,154 @@ func TestOutdoorWindowsAndTomorrowPlanningModulesPreserveDailyContent(t *testing
 	}
 }
 
+func TestDailyPlanningModulePackagesPlanningFields(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := dailyModuleContext()
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DailyPlanning})
+	if err != nil {
+		t.Fatalf("BuildModule(daily planning) error = %v", err)
+	}
+	if output.ID != module.DailyPlanning || output.StanzaName != "daily_planning" {
+		t.Fatalf("output = %#v, want daily planning stanza", output)
+	}
+	planning := moduleValue[DailyPlanningModule](t, output)
+	if len(planning.MorningReadiness) == 0 ||
+		len(planning.CommuteSchoolWorkdayConcerns) == 0 ||
+		len(planning.OvernightChangeWatch) == 0 {
+		t.Fatalf("daily planning = %#v, want populated planning fields", planning)
+	}
+	if !containsString(planning.MorningReadiness, "Morning precipitation chance peaks near 60%.") {
+		t.Fatalf("MorningReadiness = %#v, want precipitation readiness note", planning.MorningReadiness)
+	}
+	if !containsString(planning.CommuteSchoolWorkdayConcerns, "Afternoon alert overlap needs attention.") {
+		t.Fatalf("CommuteSchoolWorkdayConcerns = %#v, want alert-overlap concern", planning.CommuteSchoolWorkdayConcerns)
+	}
+	if !containsString(planning.OvernightChangeWatch, "Watch for forecast timing or intensity adjustments overnight.") {
+		t.Fatalf("OvernightChangeWatch = %#v, want overnight fallback note", planning.OvernightChangeWatch)
+	}
+	data, err := json.Marshal(output.Value)
+	if err != nil {
+		t.Fatalf("marshal daily planning: %v", err)
+	}
+	jsonText := string(data)
+	for _, field := range []string{"morning_readiness", "commute_school_workday_concerns", "overnight_change_watch"} {
+		if !strings.Contains(jsonText, field) {
+			t.Fatalf("daily planning json = %s, want field %s", jsonText, field)
+		}
+	}
+	if strings.Contains(jsonText, "tomorrow_planning") || strings.Contains(jsonText, "morningReadiness") {
+		t.Fatalf("daily planning json = %s, want daily snake_case fields only", jsonText)
+	}
+}
+
+func TestDailyPlanningModuleRejectsUnsupportedReports(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	for _, id := range []report.ID{report.Today, report.Tomorrow, report.Hourly, report.ThreeDay, report.Weekend, report.Storm} {
+		t.Run(string(id), func(t *testing.T) {
+			ctx := derivedModuleContext(id)
+			_, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DailyPlanning})
+			if err == nil || !strings.Contains(err.Error(), `module "daily_planning" is not compatible with report`) {
+				t.Fatalf("BuildModule(%s) error = %v, want incompatible report", id, err)
+			}
+		})
+	}
+}
+
+func TestDailyPlanningModuleHandlesMissingDailySummary(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := dailyModuleContext()
+	ctx.Derived.DailySummaries = nil
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.DailyPlanning})
+	if err != nil {
+		t.Fatalf("BuildModule(daily planning) error = %v", err)
+	}
+	planning := moduleValue[DailyPlanningModule](t, output)
+	if len(planning.MorningReadiness) != 0 ||
+		len(planning.CommuteSchoolWorkdayConcerns) != 0 ||
+		len(planning.OvernightChangeWatch) != 0 {
+		t.Fatalf("daily planning = %#v, want empty output without daily summary", planning)
+	}
+}
+
+func TestTodayPlanningModulePackagesPlanningFields(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := todayModuleContext()
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.TodayPlanning})
+	if err != nil {
+		t.Fatalf("BuildModule(today planning) error = %v", err)
+	}
+	if output.ID != module.TodayPlanning || output.StanzaName != "today_planning" {
+		t.Fatalf("output = %#v, want today planning stanza", output)
+	}
+	planning := moduleValue[TodayPlanningModule](t, output)
+	if len(planning.MorningReadiness) == 0 ||
+		len(planning.CommuteSchoolWorkdayConcerns) == 0 ||
+		len(planning.OutdoorPlanning) == 0 ||
+		len(planning.LateDayChangeWatch) == 0 {
+		t.Fatalf("today planning = %#v, want populated planning fields", planning)
+	}
+	if !containsString(planning.MorningReadiness, "Morning precipitation chance peaks near 60%.") {
+		t.Fatalf("MorningReadiness = %#v, want precipitation readiness note", planning.MorningReadiness)
+	}
+	if !containsString(planning.OutdoorPlanning, "Best outdoor window: Overnight (cold risk).") ||
+		!containsString(planning.OutdoorPlanning, "Toughest outdoor window: Afternoon (high precipitation chance, gusty wind, alert overlap, heat risk).") {
+		t.Fatalf("OutdoorPlanning = %#v, want deterministic best and toughest windows", planning.OutdoorPlanning)
+	}
+	if !containsString(planning.LateDayChangeWatch, "Afternoon precipitation timing may shift; current peak is near 80%.") {
+		t.Fatalf("LateDayChangeWatch = %#v, want late-day change note", planning.LateDayChangeWatch)
+	}
+	data, err := json.Marshal(output.Value)
+	if err != nil {
+		t.Fatalf("marshal today planning: %v", err)
+	}
+	jsonText := string(data)
+	for _, field := range []string{"morning_readiness", "commute_school_workday_concerns", "outdoor_planning", "late_day_change_watch"} {
+		if !strings.Contains(jsonText, field) {
+			t.Fatalf("today planning json = %s, want field %s", jsonText, field)
+		}
+	}
+	if strings.Contains(jsonText, "morningReadiness") || strings.Contains(jsonText, "lateDayChangeWatch") {
+		t.Fatalf("today planning json = %s, want snake_case fields", jsonText)
+	}
+}
+
+func TestTodayPlanningModuleRejectsUnsupportedReports(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	for _, id := range []report.ID{report.Tomorrow, report.Daily} {
+		t.Run(string(id), func(t *testing.T) {
+			ctx := derivedModuleContext(id)
+			_, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.TodayPlanning})
+			if err == nil || !strings.Contains(err.Error(), `module "today_planning" is not compatible with report`) {
+				t.Fatalf("BuildModule(%s) error = %v, want incompatible report", id, err)
+			}
+		})
+	}
+}
+
+func TestTodayPlanningModuleHandlesMissingDailySummary(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	ctx := todayModuleContext()
+	ctx.Derived.DailySummaries = nil
+
+	output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.TodayPlanning})
+	if err != nil {
+		t.Fatalf("BuildModule(today planning) error = %v", err)
+	}
+	planning := moduleValue[TodayPlanningModule](t, output)
+	if len(planning.MorningReadiness) != 0 ||
+		len(planning.CommuteSchoolWorkdayConcerns) != 0 ||
+		len(planning.OutdoorPlanning) != 0 ||
+		len(planning.LateDayChangeWatch) != 0 {
+		t.Fatalf("today planning = %#v, want empty output without daily summary", planning)
+	}
+}
+
 func TestDerivedModulesHandleMissingData(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	ctx := derivedModuleContext(report.DailyToday)
+	ctx := derivedModuleContext(report.Daily)
 	ctx.Derived.DailySummaries = nil
 	ctx.Derived.DaypartSummaries = nil
 
@@ -430,6 +798,26 @@ func derivedModuleContext(id report.ID) ModuleContext {
 	}
 }
 
+func todayModuleContext() ModuleContext {
+	ctx := derivedModuleContext(report.Daily)
+	ctx.Resolved.Definition = report.Definition{
+		ID:       report.Today,
+		Name:     "Today Report",
+		PromptID: "weather.today_generated_text",
+	}
+	return ctx
+}
+
+func dailyModuleContext() ModuleContext {
+	ctx := derivedModuleContext(report.Tomorrow)
+	ctx.Resolved.Definition = report.Definition{
+		ID:       report.Daily,
+		Name:     "Daily Report",
+		PromptID: "weather.daily_generated_text",
+	}
+	return ctx
+}
+
 func derivedDaypart(name string, start string, end string, text string, temperature float64, apparent *float64, precip float64, gust float64) forecast.DaypartSummary {
 	hour := derivedHour(start, text, precip, temperature, apparent, gust)
 	return forecast.SummarizeDaypart(name, timeutil.Period{

internal/briefing/hourly_forecast_module.go

@@ -20,6 +20,15 @@ type HourlyForecastModule struct {
 	Periods          []HourlyForecastPeriod `json:"periods,omitempty"`
 }
 
+type HourlyForecastPromptExport 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          []HourlyForecastPromptPeriod `json:"periods,omitempty"`
+}
+
 type HourlyForecastPeriod struct {
 	HourLabel                         string   `json:"hour_label,omitempty"`
 	PeriodBegins                      string   `json:"period_begins,omitempty"`
@@ -59,6 +68,42 @@ type HourlyForecastPeriod struct {
 	RelativeHumidityPercent           *float64 `json:"relative_humidity_percent,omitempty"`
 }
 
+type HourlyForecastPromptPeriod struct {
+	PeriodBegins                      string   `json:"period_begins,omitempty"`
+	PeriodEnds                        string   `json:"period_ends,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 {
@@ -78,6 +123,66 @@ func buildHourlyForecastModule(ctx ModuleContext, _ any) (*module.Output, error)
 	return &module.Output{ID: module.HourlyForecast, StanzaName: "hourly_forecast", Value: value}, nil
 }
 
+func exportHourlyForecastPromptValue(value any) (any, error) {
+	rich, ok := value.(HourlyForecastModule)
+	if !ok {
+		return nil, unexpectedPromptExportValue(value, HourlyForecastModule{})
+	}
+	return HourlyForecastPromptExport{
+		Product:          rich.Product,
+		IssuedAt:         rich.IssuedAt,
+		UpdatedAt:        copyTime(rich.UpdatedAt),
+		SourceLocation:   rich.SourceLocation,
+		SourceLocationID: rich.SourceLocationID,
+		Periods:          hourlyForecastPromptPeriods(rich.Periods),
+	}, nil
+}
+
+func hourlyForecastPromptPeriods(periods []HourlyForecastPeriod) []HourlyForecastPromptPeriod {
+	if len(periods) == 0 {
+		return nil
+	}
+	out := make([]HourlyForecastPromptPeriod, 0, len(periods))
+	for _, period := range periods {
+		out = append(out, HourlyForecastPromptPeriod{
+			PeriodBegins:                      period.PeriodBegins,
+			PeriodEnds:                        period.PeriodEnds,
+			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:                     period.WindDirection,
+			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 hourlyForecastPeriods(periods []weatherdata.ForecastPeriod, timezone string) []HourlyForecastPeriod {
 	return hourlyForecastPeriodsWithPrecipMentionThreshold(periods, timezone, DefaultHourlyForecastPrecipMentionProbabilityThreshold)
 }

internal/briefing/metadata_module.go

@@ -44,7 +44,7 @@ func buildMetadataModule(ctx ModuleContext, _ any) (*module.Output, error) {
 		ValidPeriod:    metadata.ValidPeriod,
 		Location:       copyLocation(ctx.Location),
 		SourceWarnings: sourceWarningSummaries(ctx.Collected.SourceWarnings),
-		Alerts:         alertDigest(ctx.Collected, ctx.Derived.AlertOverlaps),
+		Alerts:         alertDigest(ctx.Collected, ctx.Derived.AlertOverlaps, ctx.Timezone),
 	}
 	return &module.Output{ID: module.Metadata, StanzaName: "metadata", Value: value}, nil
 }

internal/briefing/module_format_helpers.go

@@ -122,6 +122,17 @@ func friendlyDateTimeLabel(value time.Time, timezone string) string {
 	return value.In(location).Format("2006-01-02 at 3:04 PM")
 }
 
+func friendlyMonthDayTimeLabel(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("January 2 at 3:04 PM")
+}
+
 func friendlyDateLabel(date string, timezone string) string {
 	location, err := timeutil.LoadLocation(timezone)
 	if err != nil {

internal/briefing/modules.go

@@ -21,6 +21,8 @@ type ModuleContext struct {
 
 type ModuleBuilder func(ModuleContext, any) (*module.Output, error)
 
+type ModulePromptExporter func(value any) (any, error)
+
 type ModuleDefinition struct {
 	ID                module.ID
 	StanzaName        string
@@ -31,12 +33,17 @@ type ModuleDefinition struct {
 	MissingData       module.MissingDataBehavior
 	AllowDuplicate    bool
 	Builder           ModuleBuilder
+	PromptExporter    ModulePromptExporter
 }
 
 type ModuleRegistry struct {
 	definitions map[module.ID]ModuleDefinition
 }
 
+func unexpectedPromptExportValue(got any, want any) error {
+	return fmt.Errorf("value has type %T, want %T", got, want)
+}
+
 func DefaultModuleRegistry() (ModuleRegistry, error) {
 	return NewModuleRegistry(defaultModuleDefinitions())
 }
@@ -130,6 +137,15 @@ func (r ModuleRegistry) BuildModule(ctx ModuleContext, item module.ConfigItem) (
 	if output.StanzaName != definition.StanzaName {
 		return nil, fmt.Errorf("module %q produced stanza %q, want %q", definition.ID, output.StanzaName, definition.StanzaName)
 	}
+	if definition.PromptExporter == nil {
+		output.PromptValue = output.Value
+		return output, nil
+	}
+	promptValue, err := definition.PromptExporter(output.Value)
+	if err != nil {
+		return nil, fmt.Errorf("module %q stanza %q prompt export: %w", definition.ID, definition.StanzaName, err)
+	}
+	output.PromptValue = promptValue
 	return output, nil
 }
 
@@ -249,8 +265,8 @@ func (d ModuleDefinition) ValidateOptions(options any) error {
 }
 
 func defaultModuleDefinitions() []ModuleDefinition {
-	allReports := []report.ID{report.DailyToday, report.Tomorrow, report.Hourly, report.ThreeDay, report.Weekend, report.Storm}
-	daypartReports := []report.ID{report.DailyToday, report.Tomorrow, report.ThreeDay, report.Weekend}
+	allReports := []report.ID{report.Daily, report.Today, report.Tomorrow, report.Hourly, report.ThreeDay, report.Weekend, report.Storm}
+	daypartReports := []report.ID{report.Daily, report.Today, report.Tomorrow, report.ThreeDay, report.Weekend}
 	return []ModuleDefinition{
 		{
 			ID:                module.Metadata,
@@ -269,6 +285,7 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			SupportedReports:  allReports,
 			MissingData:       module.MissingDataOmit,
 			Builder:           buildCurrentConditionsModule,
+			PromptExporter:    exportCurrentConditionsPromptValue,
 		},
 		{
 			ID:                module.NarrativeForecast,
@@ -276,7 +293,7 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			DefaultOptions:    module.NarrativeForecastOptions{},
 			RequiredCollected: []module.FactRequirement{module.CollectedNarrativeForecast},
 			RequiredDerived:   []module.FactRequirement{module.RequiresDerivedNarrativePeriods},
-			SupportedReports:  []report.ID{report.DailyToday, report.Tomorrow},
+			SupportedReports:  []report.ID{report.Daily, report.Today, report.Tomorrow},
 			MissingData:       module.MissingDataOmit,
 			Builder:           buildNarrativeForecastModule,
 		},
@@ -286,16 +303,17 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			DefaultOptions:    module.HourlyForecastOptions{},
 			RequiredCollected: []module.FactRequirement{module.CollectedHourlyForecast},
 			RequiredDerived:   []module.FactRequirement{module.RequiresDerivedHourlyPeriods},
-			SupportedReports:  []report.ID{report.DailyToday, report.Tomorrow, report.Hourly},
+			SupportedReports:  []report.ID{report.Daily, report.Today, report.Tomorrow, report.Hourly},
 			MissingData:       module.MissingDataOmit,
 			Builder:           buildHourlyForecastModule,
+			PromptExporter:    exportHourlyForecastPromptValue,
 		},
 		{
 			ID:               module.DerivedDailySummary,
 			StanzaName:       "derived_daily_summary",
 			DefaultOptions:   module.DerivedDailySummaryOptions{},
 			RequiredDerived:  []module.FactRequirement{module.RequiresDerivedDailySummaries, module.RequiresDerivedPrecipTiming},
-			SupportedReports: []report.ID{report.DailyToday, report.Tomorrow},
+			SupportedReports: []report.ID{report.Daily, report.Today, report.Tomorrow},
 			MissingData:      module.MissingDataError,
 			Builder:          buildDerivedDailySummaryModule,
 		},
@@ -307,6 +325,7 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			SupportedReports: daypartReports,
 			MissingData:      module.MissingDataError,
 			Builder:          buildDerivedDaypartSummariesModule,
+			PromptExporter:   exportDerivedDaypartSummariesPromptValue,
 		},
 		{
 			ID:               module.PrecipTiming,
@@ -374,6 +393,15 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			MissingData:      module.MissingDataEmpty,
 			Builder:          buildOutdoorWindowsModule,
 		},
+		{
+			ID:               module.TodayPlanning,
+			StanzaName:       "today_planning",
+			DefaultOptions:   module.TodayPlanningOptions{},
+			RequiredDerived:  []module.FactRequirement{module.RequiresDerivedDailySummaries},
+			SupportedReports: []report.ID{report.Today},
+			MissingData:      module.MissingDataEmpty,
+			Builder:          buildTodayPlanningModule,
+		},
 		{
 			ID:               module.TomorrowPlanning,
 			StanzaName:       "tomorrow_planning",
@@ -383,5 +411,14 @@ func defaultModuleDefinitions() []ModuleDefinition {
 			MissingData:      module.MissingDataEmpty,
 			Builder:          buildTomorrowPlanningModule,
 		},
+		{
+			ID:               module.DailyPlanning,
+			StanzaName:       "daily_planning",
+			DefaultOptions:   module.DailyPlanningOptions{},
+			RequiredDerived:  []module.FactRequirement{module.RequiresDerivedDailySummaries},
+			SupportedReports: []report.ID{report.Daily},
+			MissingData:      module.MissingDataEmpty,
+			Builder:          buildDailyPlanningModule,
+		},
 	}
 }

internal/briefing/modules_test.go

@@ -1,6 +1,8 @@
 package briefing
 
 import (
+	"encoding/json"
+	"errors"
 	"strings"
 	"testing"
 
@@ -40,6 +42,9 @@ func TestDefaultReportModulesBuildSnapshots(t *testing.T) {
 					t.Fatalf("BuildModule(%s) error = %v", item.ID, err)
 				}
 				if output != nil {
+					if output.DataPackageValue() == nil {
+						t.Fatalf("BuildModule(%s) data package value = nil", item.ID)
+					}
 					outputs = append(outputs, *output)
 				}
 			}
@@ -54,8 +59,223 @@ func TestDefaultReportModulesBuildSnapshots(t *testing.T) {
 	}
 }
 
-func TestHourlyDefaultModuleOptions(t *testing.T) {
-	definition := report.DefaultRegistry().MustLookup(report.Hourly)
+func TestDefaultModuleDefinitionsDeclarePromptExportPolicy(t *testing.T) {
+	customExporters := map[module.ID]struct{}{
+		module.CurrentConditions:       {},
+		module.HourlyForecast:          {},
+		module.DerivedDaypartSummaries: {},
+	}
+	passThroughExporters := map[module.ID]struct{}{
+		module.Metadata:                {},
+		module.NarrativeForecast:       {},
+		module.DerivedDailySummary:     {},
+		module.PrecipTiming:            {},
+		module.AlertDigest:             {},
+		module.SPCConvectiveOutlooks:   {},
+		module.AreaForecastDiscussion:  {},
+		module.SPCConvectiveDiscussion: {},
+		module.WeatherStory:            {},
+		module.OutdoorWindows:          {},
+		module.TodayPlanning:           {},
+		module.TomorrowPlanning:        {},
+		module.DailyPlanning:           {},
+	}
+
+	for _, definition := range defaultModuleDefinitions() {
+		_, custom := customExporters[definition.ID]
+		_, passThrough := passThroughExporters[definition.ID]
+		if custom == passThrough {
+			t.Fatalf("module %q exporter policy custom=%v passThrough=%v, want exactly one policy", definition.ID, custom, passThrough)
+		}
+		if custom && definition.PromptExporter == nil {
+			t.Fatalf("module %q PromptExporter = nil, want custom prompt exporter", definition.ID)
+		}
+		if passThrough && definition.PromptExporter != nil {
+			t.Fatalf("module %q PromptExporter is set, want default pass-through", definition.ID)
+		}
+	}
+}
+
+func TestModuleRegistryAddsPassThroughPromptValue(t *testing.T) {
+	registry, err := NewModuleRegistry([]ModuleDefinition{
+		{
+			ID:         module.Metadata,
+			StanzaName: "metadata",
+			Builder: func(ModuleContext, any) (*module.Output, error) {
+				return &module.Output{
+					ID:         module.Metadata,
+					StanzaName: "metadata",
+					Value:      testRegistryValue{Message: "rich"},
+				}, nil
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewModuleRegistry() error = %v", err)
+	}
+
+	output, err := registry.BuildModule(testRegistryModuleContext(), module.ConfigItem{ID: module.Metadata})
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	if output == nil {
+		t.Fatal("BuildModule() output = nil, want output")
+	}
+	if output.PromptValue != output.Value {
+		t.Fatalf("PromptValue = %#v, want pass-through rich value %#v", output.PromptValue, output.Value)
+	}
+	if output.DataPackageValue() != output.Value {
+		t.Fatalf("DataPackageValue() = %#v, want rich value", output.DataPackageValue())
+	}
+}
+
+func TestModuleRegistryAddsCustomPromptValue(t *testing.T) {
+	registry, err := NewModuleRegistry([]ModuleDefinition{
+		{
+			ID:         module.Metadata,
+			StanzaName: "metadata",
+			Builder: func(ModuleContext, any) (*module.Output, error) {
+				return &module.Output{
+					ID:         module.Metadata,
+					StanzaName: "metadata",
+					Value:      testRegistryValue{Message: "rich"},
+				}, nil
+			},
+			PromptExporter: func(value any) (any, error) {
+				rich, ok := value.(testRegistryValue)
+				if !ok {
+					return nil, errors.New("unexpected rich value type")
+				}
+				return testRegistryValue{Message: rich.Message + " prompt"}, nil
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewModuleRegistry() error = %v", err)
+	}
+
+	output, err := registry.BuildModule(testRegistryModuleContext(), module.ConfigItem{ID: module.Metadata})
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	got, ok := output.PromptValue.(testRegistryValue)
+	if !ok {
+		t.Fatalf("PromptValue type = %T, want testRegistryValue", output.PromptValue)
+	}
+	if got.Message != "rich prompt" {
+		t.Fatalf("PromptValue = %#v, want custom prompt value", got)
+	}
+	if output.DataPackageValue() != output.PromptValue {
+		t.Fatalf("DataPackageValue() = %#v, want custom prompt value", output.DataPackageValue())
+	}
+	if output.Value.(testRegistryValue).Message != "rich" {
+		t.Fatalf("Value = %#v, want rich value unchanged", output.Value)
+	}
+}
+
+func TestModuleRegistryWrapsPromptExporterErrors(t *testing.T) {
+	registry, err := NewModuleRegistry([]ModuleDefinition{
+		{
+			ID:         module.Metadata,
+			StanzaName: "metadata",
+			Builder: func(ModuleContext, any) (*module.Output, error) {
+				return &module.Output{ID: module.Metadata, StanzaName: "metadata", Value: testRegistryValue{Message: "rich"}}, nil
+			},
+			PromptExporter: func(any) (any, error) {
+				return nil, errors.New("unsupported value")
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewModuleRegistry() error = %v", err)
+	}
+
+	_, err = registry.BuildModule(testRegistryModuleContext(), module.ConfigItem{ID: module.Metadata})
+	if err == nil ||
+		!strings.Contains(err.Error(), `module "metadata" stanza "metadata" prompt export`) ||
+		!strings.Contains(err.Error(), "unsupported value") {
+		t.Fatalf("BuildModule() error = %v, want wrapped exporter error", err)
+	}
+}
+
+func TestModuleRegistryValidatesOutputBeforePromptExport(t *testing.T) {
+	called := false
+	registry, err := NewModuleRegistry([]ModuleDefinition{
+		{
+			ID:         module.Metadata,
+			StanzaName: "metadata",
+			Builder: func(ModuleContext, any) (*module.Output, error) {
+				return &module.Output{ID: module.CurrentConditions, StanzaName: "metadata", Value: testRegistryValue{Message: "rich"}}, nil
+			},
+			PromptExporter: func(any) (any, error) {
+				called = true
+				return testRegistryValue{Message: "prompt"}, nil
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewModuleRegistry() error = %v", err)
+	}
+
+	_, err = registry.BuildModule(testRegistryModuleContext(), module.ConfigItem{ID: module.Metadata})
+	if err == nil || !strings.Contains(err.Error(), `module "metadata" produced output id "current_conditions"`) {
+		t.Fatalf("BuildModule() error = %v, want output id validation error", err)
+	}
+	if called {
+		t.Fatal("PromptExporter called before output validation")
+	}
+}
+
+func TestModuleRegistryPromptValueIsNotPersistedInSnapshotJSON(t *testing.T) {
+	registry, err := NewModuleRegistry([]ModuleDefinition{
+		{
+			ID:         module.Metadata,
+			StanzaName: "metadata",
+			Builder: func(ModuleContext, any) (*module.Output, error) {
+				return &module.Output{ID: module.Metadata, StanzaName: "metadata", Value: testRegistryValue{Message: "rich"}}, nil
+			},
+			PromptExporter: func(any) (any, error) {
+				return testRegistryValue{Message: "prompt-only"}, nil
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewModuleRegistry() error = %v", err)
+	}
+	output, err := registry.BuildModule(testRegistryModuleContext(), module.ConfigItem{ID: module.Metadata})
+	if err != nil {
+		t.Fatalf("BuildModule() error = %v", err)
+	}
+	snapshot, err := module.NewSnapshot([]module.Output{*output})
+	if err != nil {
+		t.Fatalf("NewSnapshot() error = %v", err)
+	}
+	data, err := json.Marshal(snapshot)
+	if err != nil {
+		t.Fatalf("Marshal() error = %v", err)
+	}
+	text := string(data)
+	if !strings.Contains(text, `"message":"rich"`) {
+		t.Fatalf("snapshot JSON missing rich value: %s", text)
+	}
+	if strings.Contains(text, "prompt-only") || strings.Contains(text, "promptValue") || strings.Contains(text, "PromptValue") {
+		t.Fatalf("snapshot JSON includes runtime-only prompt value: %s", text)
+	}
+}
+
+func TestDefaultAreaForecastDiscussionModuleOptions(t *testing.T) {
+	tests := []struct {
+		id           report.ID
+		wantSections string
+	}{
+		{id: report.Daily, wantSections: "long_term"},
+		{id: report.Hourly, wantSections: "key_messages,short_term"},
+	}
+
+	registry := report.DefaultRegistry()
+	for _, tt := range tests {
+		t.Run(string(tt.id), func(t *testing.T) {
+			definition := registry.MustLookup(tt.id)
 			var found bool
 			for _, item := range definition.Modules {
 				if item.ID != module.AreaForecastDiscussion {
@@ -66,18 +286,39 @@ func TestHourlyDefaultModuleOptions(t *testing.T) {
 				if !ok {
 					t.Fatalf("AFD options type = %T, want AreaForecastDiscussionOptions", item.Options)
 				}
-		if strings.Join(options.Sections, ",") != "key_messages,short_term" {
-			t.Fatalf("AFD sections = %#v, want key messages and short term", options.Sections)
+				if strings.Join(options.Sections, ",") != tt.wantSections {
+					t.Fatalf("AFD sections = %#v, want %s", options.Sections, tt.wantSections)
 				}
 			}
 			if !found {
-		t.Fatal("hourly default modules missing area_forecast_discussion")
+				t.Fatal("default modules missing area_forecast_discussion")
+			}
+		})
+	}
+
+	for _, id := range []report.ID{report.Today, report.Tomorrow} {
+		t.Run(string(id), func(t *testing.T) {
+			definition := registry.MustLookup(id)
+			var found bool
+			for _, item := range definition.Modules {
+				if item.ID != module.AreaForecastDiscussion {
+					continue
+				}
+				found = true
+				if item.Options != nil {
+					t.Fatalf("AFD options = %#v, want default all sections", item.Options)
+				}
+			}
+			if !found {
+				t.Fatal("default modules missing area_forecast_discussion")
+			}
+		})
 	}
 }
 
 func TestModuleRegistryRejectsUnknownModule(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{{ID: module.ID("unknown")}})
+	err := registry.ValidateComposition(report.Daily, []module.ConfigItem{{ID: module.ID("unknown")}})
 	if err == nil || !strings.Contains(err.Error(), `unknown module "unknown"`) {
 		t.Fatalf("error = %v, want unknown module", err)
 	}
@@ -85,7 +326,7 @@ func TestModuleRegistryRejectsUnknownModule(t *testing.T) {
 
 func TestModuleRegistryRejectsDuplicateModuleIDs(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{
+	err := registry.ValidateComposition(report.Daily, []module.ConfigItem{
 		{ID: module.Metadata},
 		{ID: module.Metadata},
 	})
@@ -106,12 +347,64 @@ func TestModuleRegistryRejectsDuplicateStanzaNames(t *testing.T) {
 
 func TestModuleRegistryRejectsIncompatibleReports(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{{ID: module.TomorrowPlanning}})
-	if err == nil || !strings.Contains(err.Error(), `module "tomorrow_planning" is not compatible with report "daily_today"`) {
+	err := registry.ValidateComposition(report.Daily, []module.ConfigItem{{ID: module.TomorrowPlanning}})
+	if err == nil || !strings.Contains(err.Error(), `module "tomorrow_planning" is not compatible with report "daily"`) {
 		t.Fatalf("error = %v, want incompatible report", err)
 	}
 }
 
+func TestModuleRegistryValidatesTodayPlanningSupport(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	if err := registry.ValidateComposition(report.Today, []module.ConfigItem{{ID: module.TodayPlanning}}); err != nil {
+		t.Fatalf("ValidateComposition(today) error = %v", err)
+	}
+	for _, id := range []report.ID{report.Tomorrow, report.Daily} {
+		t.Run(string(id), func(t *testing.T) {
+			err := registry.ValidateComposition(id, []module.ConfigItem{{ID: module.TodayPlanning}})
+			if err == nil || !strings.Contains(err.Error(), `module "today_planning" is not compatible with report`) {
+				t.Fatalf("ValidateComposition(%s) error = %v, want incompatible report", id, err)
+			}
+		})
+	}
+}
+
+func TestModuleRegistryValidatesDailyPlanningSupport(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	if err := registry.ValidateComposition(report.Daily, []module.ConfigItem{{ID: module.DailyPlanning}}); err != nil {
+		t.Fatalf("ValidateComposition(daily) error = %v", err)
+	}
+	for _, id := range []report.ID{report.Today, report.Tomorrow, report.Hourly, report.ThreeDay, report.Weekend, report.Storm} {
+		t.Run(string(id), func(t *testing.T) {
+			err := registry.ValidateComposition(id, []module.ConfigItem{{ID: module.DailyPlanning}})
+			if err == nil || !strings.Contains(err.Error(), `module "daily_planning" is not compatible with report`) {
+				t.Fatalf("ValidateComposition(%s) error = %v, want incompatible report", id, err)
+			}
+		})
+	}
+}
+
+func TestModuleRegistrySupportsTodayEligibleModules(t *testing.T) {
+	registry := MustDefaultModuleRegistry()
+	err := registry.ValidateComposition(report.Today, []module.ConfigItem{
+		{ID: module.Metadata},
+		{ID: module.CurrentConditions},
+		{ID: module.NarrativeForecast},
+		{ID: module.HourlyForecast},
+		{ID: module.DerivedDailySummary},
+		{ID: module.DerivedDaypartSummaries},
+		{ID: module.PrecipTiming},
+		{ID: module.AlertDigest},
+		{ID: module.SPCConvectiveOutlooks},
+		{ID: module.AreaForecastDiscussion},
+		{ID: module.SPCConvectiveDiscussion},
+		{ID: module.WeatherStory},
+		{ID: module.OutdoorWindows},
+	})
+	if err != nil {
+		t.Fatalf("ValidateComposition(today eligible modules) error = %v", err)
+	}
+}
+
 func TestModuleRegistryRejectsHourlyIncompatibleModules(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	for _, id := range []module.ID{
@@ -119,7 +412,9 @@ func TestModuleRegistryRejectsHourlyIncompatibleModules(t *testing.T) {
 		module.DerivedDailySummary,
 		module.DerivedDaypartSummaries,
 		module.OutdoorWindows,
+		module.TodayPlanning,
 		module.TomorrowPlanning,
+		module.DailyPlanning,
 	} {
 		t.Run(string(id), func(t *testing.T) {
 			err := registry.ValidateComposition(report.Hourly, []module.ConfigItem{{ID: id}})
@@ -150,7 +445,7 @@ func TestModuleRegistryRejectsUnsupportedMissingDataWarn(t *testing.T) {
 
 func TestModuleRegistryRejectsInvalidOptionShapes(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{
+	err := registry.ValidateComposition(report.Daily, []module.ConfigItem{
 		{ID: module.Metadata, Options: module.CurrentConditionsOptions{}},
 	})
 	if err == nil || !strings.Contains(err.Error(), `module "metadata" options have type module.CurrentConditionsOptions, want module.MetadataOptions`) {
@@ -160,7 +455,7 @@ func TestModuleRegistryRejectsInvalidOptionShapes(t *testing.T) {
 
 func TestModuleRegistryAcceptsTypedOptions(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
-	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{
+	err := registry.ValidateComposition(report.Daily, []module.ConfigItem{
 		{ID: module.Metadata, Options: module.MetadataOptions{}},
 		{ID: module.CurrentConditions, Options: &module.CurrentConditionsOptions{}},
 	})
@@ -196,3 +491,15 @@ func TestSPCConvectiveOutlookDerivedRequirementAvailability(t *testing.T) {
 func noopModuleBuilder(ModuleContext, any) (*module.Output, error) {
 	return &module.Output{ID: module.Metadata, StanzaName: "metadata", Value: struct{}{}}, nil
 }
+
+type testRegistryValue struct {
+	Message string `json:"message"`
+}
+
+func testRegistryModuleContext() ModuleContext {
+	return ModuleContext{
+		Resolved: report.Resolved{
+			Definition: report.DefaultRegistry().MustLookup(report.Daily),
+		},
+	}
+}

internal/briefing/package.go

@@ -185,7 +185,7 @@ func alertStatus(bundle *weatherdata.Bundle) *AlertStatus {
 
 func variantForReport(id report.ID) string {
 	switch id {
-	case report.DailyToday:
+	case report.Daily, report.Today:
 		return "today"
 	case report.Tomorrow:
 		return "tomorrow"

internal/briefing/precip_timing_module.go

@@ -1,10 +1,19 @@
 package briefing
 
 import (
+	"fmt"
+	"strings"
+
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
 )
 
+const (
+	precipTimingChanceLowerBound = 40
+	precipTimingLikelyLowerBound = 50
+	precipTimingExpectLowerBound = 70
+)
+
 type PrecipTimingModule struct {
 	MaxPopPercent        *int                        `json:"max_pop_percent,omitempty"`
 	MaxPopTime           string                      `json:"max_pop_time,omitempty"`
@@ -21,6 +30,8 @@ type PrecipitationWindowModule struct {
 	MaxPopPercent         *int   `json:"max_pop_percent,omitempty"`
 	MaxPopTime            string `json:"max_pop_time,omitempty"`
 	MaxPopHourLabel       string `json:"max_pop_hour_label,omitempty"`
+	PrecipitationType     string `json:"precipitation_type,omitempty"`
+	ExpectationPhrase     string `json:"expectation_phrase,omitempty"`
 }
 
 func buildPrecipTimingModule(ctx ModuleContext, _ any) (*module.Output, error) {
@@ -49,7 +60,50 @@ func precipTimingValue(timing forecast.PrecipTiming, timezone string) PrecipTimi
 		item.MaxPopPercent = roundedInt(&window.MaxPrecipitationProbability.Value)
 		item.MaxPopTime = clockLabel(window.MaxPrecipitationProbability.Time, timezone)
 		item.MaxPopHourLabel = hourMinuteLabel(window.MaxPrecipitationProbability.Time, timezone)
+		item.PrecipitationType = precipitationWindowType(window.TextDescriptions)
+		if item.MaxPopPercent != nil {
+			item.ExpectationPhrase = precipitationWindowExpectationPhrase(*item.MaxPopPercent, item.PrecipitationType)
+		}
 		value.PrecipitationWindows = append(value.PrecipitationWindows, item)
 	}
 	return value
 }
+
+func precipitationWindowType(descriptions []string) string {
+	combined := strings.ToLower(strings.Join(descriptions, " "))
+	switch {
+	case (strings.Contains(combined, "thunderstorm") || strings.Contains(combined, "t-storm")) &&
+		(strings.Contains(combined, "shower") || strings.Contains(combined, "rain")):
+		return "showers and thunderstorms"
+	case strings.Contains(combined, "freezing rain"):
+		return "freezing rain"
+	case strings.Contains(combined, "thunderstorm") || strings.Contains(combined, "t-storm"):
+		return "thunderstorms"
+	case strings.Contains(combined, "shower"):
+		return "showers"
+	case strings.Contains(combined, "snow"):
+		return "snow"
+	case strings.Contains(combined, "drizzle"):
+		return "drizzle"
+	case strings.Contains(combined, "rain"):
+		return "rain"
+	default:
+		return "precipitation"
+	}
+}
+
+func precipitationWindowExpectationPhrase(maxPopPercent int, precipitationType string) string {
+	if precipitationType == "" {
+		precipitationType = "precipitation"
+	}
+	switch {
+	case maxPopPercent >= precipTimingExpectLowerBound:
+		return fmt.Sprintf("Expect %s.", precipitationType)
+	case maxPopPercent >= precipTimingLikelyLowerBound:
+		return fmt.Sprintf("%s likely.", sentenceCase(precipitationType))
+	case maxPopPercent >= precipTimingChanceLowerBound:
+		return fmt.Sprintf("Chance of %s.", precipitationType)
+	default:
+		return ""
+	}
+}

internal/briefing/spc_convective_discussion_module.go

@@ -8,8 +8,8 @@ import (
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
 )
 
-const defaultSPCConvectiveDiscussionMinimumSeverityRank = 3
-const spcCategoricalOutlookType = "categorical"
+const defaultSPCConvectiveDiscussionMinimumSeverityRank = defaultSPCRiskDigestMinimumSeverityRank
+const spcCategoricalOutlookType = defaultSPCRiskDigestOutlookType
 
 type SPCConvectiveDiscussionModule struct {
 	IncludedBecause string                          `json:"included_because"`

internal/briefing/spc_convective_outlooks_module.go

@@ -1,13 +1,18 @@
 package briefing
 
 import (
+	"strings"
 	"time"
+	"unicode"
 
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
 )
 
+const defaultSPCRiskDigestOutlookType = "categorical"
+const defaultSPCRiskDigestMinimumSeverityRank = 3
+
 type SPCConvectiveOutlooksModule struct {
 	Checked      bool                         `json:"checked"`
 	AsOf         string                       `json:"as_of,omitempty"`
@@ -16,6 +21,7 @@ type SPCConvectiveOutlooksModule struct {
 	LocationName string                       `json:"location_name,omitempty"`
 	OutlookCount int                          `json:"outlook_count"`
 	Outlooks     []SPCConvectiveOutlookRecord `json:"outlooks,omitempty"`
+	RiskDigest   []SPCConvectiveOutlookDigest `json:"risk_digest,omitempty"`
 }
 
 type SPCConvectiveOutlookRecord struct {
@@ -30,6 +36,13 @@ type SPCConvectiveOutlookRecord struct {
 	ImageURL         string `json:"image_url,omitempty"`
 }
 
+type SPCConvectiveOutlookDigest struct {
+	LabelText    string `json:"label_text,omitempty"`
+	RiskLabel    string `json:"risk_label,omitempty"`
+	PeriodBegins string `json:"period_begins,omitempty"`
+	PeriodEnds   string `json:"period_ends,omitempty"`
+}
+
 func buildSPCConvectiveOutlooksModule(ctx ModuleContext, _ any) (*module.Output, error) {
 	value := SPCConvectiveOutlooksModule{}
 	run := ctx.Collected.SPCConvectiveOutlooks
@@ -49,10 +62,23 @@ func buildSPCConvectiveOutlooksModule(ctx ModuleContext, _ any) (*module.Output,
 	}
 
 	value.Outlooks = spcConvectiveOutlookRecords(ctx.Derived.SPCConvectiveOutlooks, ctx.Resolved.ValidPeriod, ctx.Timezone)
+	value.RiskDigest = spcConvectiveOutlookRiskDigest(ctx.Derived.SPCConvectiveOutlooks, ctx.Resolved.ValidPeriod, ctx.Timezone, defaultSPCRiskDigestPolicy())
 	value.OutlookCount = len(value.Outlooks)
 	return &module.Output{ID: module.SPCConvectiveOutlooks, StanzaName: string(module.SPCConvectiveOutlooks), Value: value}, nil
 }
 
+type spcRiskDigestPolicy struct {
+	OutlookType         string
+	MinimumSeverityRank int
+}
+
+func defaultSPCRiskDigestPolicy() spcRiskDigestPolicy {
+	return spcRiskDigestPolicy{
+		OutlookType:         defaultSPCRiskDigestOutlookType,
+		MinimumSeverityRank: defaultSPCRiskDigestMinimumSeverityRank,
+	}
+}
+
 func spcConvectiveOutlookRecords(outlooks []weatherdata.ConvectiveOutlook, reportPeriod timeutil.Period, timezone string) []SPCConvectiveOutlookRecord {
 	records := make([]SPCConvectiveOutlookRecord, 0, len(outlooks))
 	for _, outlook := range outlooks {
@@ -75,6 +101,42 @@ func spcConvectiveOutlookRecords(outlooks []weatherdata.ConvectiveOutlook, repor
 	return records
 }
 
+func spcConvectiveOutlookRiskDigest(outlooks []weatherdata.ConvectiveOutlook, reportPeriod timeutil.Period, timezone string, policy spcRiskDigestPolicy) []SPCConvectiveOutlookDigest {
+	records := make([]SPCConvectiveOutlookDigest, 0, len(outlooks))
+	for _, outlook := range outlooks {
+		if outlook.OutlookType != policy.OutlookType {
+			continue
+		}
+		if outlook.SeverityRank == nil || *outlook.SeverityRank < policy.MinimumSeverityRank {
+			continue
+		}
+		if !outlook.ContainsLocation {
+			continue
+		}
+		outlookPeriod := timeutil.Period{Start: outlook.ValidFrom, End: outlook.ValidTo}
+		if !outlookPeriod.IsValid() || !outlookPeriod.Overlaps(reportPeriod) {
+			continue
+		}
+		records = append(records, SPCConvectiveOutlookDigest{
+			LabelText:    outlook.LabelText,
+			RiskLabel:    spcRiskDigestLabel(outlook.LabelText),
+			PeriodBegins: friendlyMonthDayTimeLabel(outlookPeriod.Start, timezone),
+			PeriodEnds:   friendlyMonthDayTimeLabel(outlookPeriod.End, timezone),
+		})
+	}
+	return records
+}
+
+func spcRiskDigestLabel(labelText string) string {
+	label := strings.TrimSpace(labelText)
+	if label == "" {
+		return ""
+	}
+	runes := []rune(strings.ToLower(label))
+	runes[0] = unicode.ToUpper(runes[0])
+	return string(runes)
+}
+
 func friendlyOptionalTime(value *time.Time, timezone string) string {
 	if value == nil {
 		return ""

internal/briefing/spc_convective_outlooks_module_test.go

@@ -71,12 +71,19 @@ func TestSPCConvectiveOutlooksModuleBuildsPromptSafeRiskProduct(t *testing.T) {
 	if !got.ContainsLocation || got.ImageURL == "" {
 		t.Fatalf("outlook = %#v, want location flag and image URL", got)
 	}
+	if len(value.RiskDigest) != 1 {
+		t.Fatalf("RiskDigest length = %d, want 1", len(value.RiskDigest))
+	}
+	digest := value.RiskDigest[0]
+	if digest.LabelText != "Slight Risk" || digest.RiskLabel != "Slight risk" || digest.PeriodBegins != "May 29 at 11:00 AM" || digest.PeriodEnds != "May 30 at 7:00 AM" {
+		t.Fatalf("risk digest = %#v, want prompt-facing slight risk record", digest)
+	}
 	data, err := json.Marshal(output.Value)
 	if err != nil {
 		t.Fatalf("Marshal() error = %v", err)
 	}
 	text := string(data)
-	for _, field := range []string{"checked", "as_of", "issued_at", "location_id", "location_name", "outlook_count", "outlooks", "period_begins", "period_ends", "contains_location", "image_url"} {
+	for _, field := range []string{"checked", "as_of", "issued_at", "location_id", "location_name", "outlook_count", "outlooks", "risk_digest", "period_begins", "period_ends", "contains_location", "image_url"} {
 		if !strings.Contains(text, field) {
 			t.Fatalf("json = %s, want field %s", text, field)
 		}
@@ -88,6 +95,71 @@ func TestSPCConvectiveOutlooksModuleBuildsPromptSafeRiskProduct(t *testing.T) {
 	}
 }
 
+func TestSPCRiskDigestDefaultPolicyConstants(t *testing.T) {
+	if defaultSPCRiskDigestOutlookType != "categorical" {
+		t.Fatalf("defaultSPCRiskDigestOutlookType = %q, want categorical", defaultSPCRiskDigestOutlookType)
+	}
+	if defaultSPCRiskDigestMinimumSeverityRank != 3 {
+		t.Fatalf("defaultSPCRiskDigestMinimumSeverityRank = %d, want 3", defaultSPCRiskDigestMinimumSeverityRank)
+	}
+}
+
+func TestSPCConvectiveOutlooksRiskDigestFilters(t *testing.T) {
+	tests := []struct {
+		name     string
+		outlook  weatherdata.ConvectiveOutlook
+		wantRisk bool
+	}{
+		{
+			name: "categorical slight risk included",
+			outlook: spcRiskDigestTestOutlook("categorical", "Slight Risk", 3, true,
+				"2026-05-29T11:00:00-05:00", "2026-05-30T07:00:00-05:00"),
+			wantRisk: true,
+		},
+		{
+			name: "marginal risk excluded",
+			outlook: spcRiskDigestTestOutlook("categorical", "Marginal Risk", 2, true,
+				"2026-05-29T11:00:00-05:00", "2026-05-30T07:00:00-05:00"),
+		},
+		{
+			name: "non categorical high rank excluded",
+			outlook: spcRiskDigestTestOutlook("wind", "30% Wind Risk", 30, true,
+				"2026-05-29T11:00:00-05:00", "2026-05-30T07:00:00-05:00"),
+		},
+		{
+			name: "non overlapping excluded",
+			outlook: spcRiskDigestTestOutlook("categorical", "Enhanced Risk", 4, true,
+				"2026-05-30T07:00:00-05:00", "2026-05-31T07:00:00-05:00"),
+		},
+		{
+			name: "location miss excluded",
+			outlook: spcRiskDigestTestOutlook("categorical", "Moderate Risk", 5, false,
+				"2026-05-29T11:00:00-05:00", "2026-05-30T07:00:00-05:00"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			registry := MustDefaultModuleRegistry()
+			ctx := testModuleContext()
+			ctx.Collected.SPCConvectiveOutlooks = &weatherdata.ConvectiveOutlookRun{
+				Outlooks: []weatherdata.ConvectiveOutlook{tt.outlook},
+			}
+			ctx.Derived.SPCConvectiveOutlooks = []weatherdata.ConvectiveOutlook{tt.outlook}
+
+			output, err := registry.BuildModule(ctx, module.ConfigItem{ID: module.SPCConvectiveOutlooks})
+			if err != nil {
+				t.Fatalf("BuildModule() error = %v", err)
+			}
+			value := moduleValue[SPCConvectiveOutlooksModule](t, output)
+			gotRisk := len(value.RiskDigest) > 0
+			if gotRisk != tt.wantRisk {
+				t.Fatalf("RiskDigest = %#v, want included=%v", value.RiskDigest, tt.wantRisk)
+			}
+		})
+	}
+}
+
 func TestSPCConvectiveOutlooksModuleSkipsNonOverlappingOutlooks(t *testing.T) {
 	registry := MustDefaultModuleRegistry()
 	ctx := testModuleContext()
@@ -117,6 +189,9 @@ func TestSPCConvectiveOutlooksModuleSkipsNonOverlappingOutlooks(t *testing.T) {
 	if value.OutlookCount != 0 || len(value.Outlooks) != 0 {
 		t.Fatalf("value = %#v, want non-overlapping outlook omitted", value)
 	}
+	if len(value.RiskDigest) != 0 {
+		t.Fatalf("RiskDigest = %#v, want non-overlapping outlook omitted", value.RiskDigest)
+	}
 }
 
 func TestSPCConvectiveOutlooksModuleBuildsCheckedEmptyStanza(t *testing.T) {
@@ -167,3 +242,16 @@ func TestSPCConvectiveOutlooksModuleBuildsUncheckedStanzaForMissingSource(t *tes
 		t.Fatalf("missing source value = %#v, want unchecked empty stanza", value)
 	}
 }
+
+func spcRiskDigestTestOutlook(outlookType string, labelText string, rank int, containsLocation bool, validFrom string, validTo string) weatherdata.ConvectiveOutlook {
+	return weatherdata.ConvectiveOutlook{
+		ID:               labelText,
+		Day:              1,
+		OutlookType:      outlookType,
+		LabelText:        labelText,
+		SeverityRank:     &rank,
+		ValidFrom:        mustParseModuleTime(validFrom),
+		ValidTo:          mustParseModuleTime(validTo),
+		ContainsLocation: containsLocation,
+	}
+}

internal/briefing/summary_helpers.go

@@ -28,6 +28,19 @@ type TomorrowPlanning struct {
 	OvernightChangeWatch         []string
 }
 
+type morningCommuteOvernightPlanning struct {
+	MorningReadiness             []string
+	CommuteSchoolWorkdayConcerns []string
+	OvernightChangeWatch         []string
+}
+
+type TodayPlanning struct {
+	MorningReadiness             []string
+	CommuteSchoolWorkdayConcerns []string
+	OutdoorPlanning              []string
+	LateDayChangeWatch           []string
+}
+
 func buildOutdoorWindows(dayparts []forecast.DaypartSummary) OutdoorWindows {
 	var best *OutdoorWindow
 	var worst *OutdoorWindow
@@ -48,8 +61,60 @@ func buildOutdoorWindows(dayparts []forecast.DaypartSummary) OutdoorWindows {
 	return OutdoorWindows{Best: best, Worst: worst}
 }
 
+func buildTodayPlanning(summary *forecast.DailySummary) *TodayPlanning {
+	planning := &TodayPlanning{}
+	morning := daypartNamed(summary.Dayparts, "morning")
+	if morning != nil {
+		planning.MorningReadiness = append(planning.MorningReadiness, readinessNotes(*morning)...)
+	}
+	if len(planning.MorningReadiness) == 0 {
+		planning.MorningReadiness = append(planning.MorningReadiness, "Morning weather looks routine based on the available hourly forecast.")
+	}
+
+	for _, daypart := range summary.Dayparts {
+		if daypart.Name == "overnight" || daypart.Name == "evening" {
+			continue
+		}
+		planning.CommuteSchoolWorkdayConcerns = appendUnique(planning.CommuteSchoolWorkdayConcerns, concernNotes(daypart)...)
+	}
+	for _, alert := range summary.AlertOverlaps {
+		if alert.Event != "" {
+			planning.CommuteSchoolWorkdayConcerns = appendUnique(planning.CommuteSchoolWorkdayConcerns, "Active alert to plan around: "+alert.Event+".")
+		}
+	}
+	if len(planning.CommuteSchoolWorkdayConcerns) == 0 {
+		planning.CommuteSchoolWorkdayConcerns = append(planning.CommuteSchoolWorkdayConcerns, "No major commute, school, or workday weather concerns stand out in the available forecast.")
+	}
+
+	planning.OutdoorPlanning = append(planning.OutdoorPlanning, outdoorPlanningNotes(summary.Dayparts)...)
+	if len(planning.OutdoorPlanning) == 0 {
+		planning.OutdoorPlanning = append(planning.OutdoorPlanning, "No standout outdoor weather constraints are evident in the available forecast.")
+	}
+
+	for _, name := range []string{"afternoon", "evening"} {
+		daypart := daypartNamed(summary.Dayparts, name)
+		if daypart != nil {
+			planning.LateDayChangeWatch = appendUnique(planning.LateDayChangeWatch, lateDayWatchNotes(*daypart)...)
+		}
+	}
+	if len(planning.LateDayChangeWatch) == 0 {
+		planning.LateDayChangeWatch = append(planning.LateDayChangeWatch, "Watch for forecast timing or intensity adjustments later today.")
+	}
+
+	return planning
+}
+
 func buildTomorrowPlanning(summary *forecast.DailySummary) *TomorrowPlanning {
-	planning := &TomorrowPlanning{}
+	base := buildMorningCommuteOvernightPlanning(summary)
+	return &TomorrowPlanning{
+		MorningReadiness:             append([]string(nil), base.MorningReadiness...),
+		CommuteSchoolWorkdayConcerns: append([]string(nil), base.CommuteSchoolWorkdayConcerns...),
+		OvernightChangeWatch:         append([]string(nil), base.OvernightChangeWatch...),
+	}
+}
+
+func buildMorningCommuteOvernightPlanning(summary *forecast.DailySummary) *morningCommuteOvernightPlanning {
+	planning := &morningCommuteOvernightPlanning{}
 	morning := daypartNamed(summary.Dayparts, "morning")
 	if morning != nil {
 		planning.MorningReadiness = append(planning.MorningReadiness, readinessNotes(*morning)...)
@@ -84,6 +149,18 @@ func buildTomorrowPlanning(summary *forecast.DailySummary) *TomorrowPlanning {
 	return planning
 }
 
+func outdoorPlanningNotes(dayparts []forecast.DaypartSummary) []string {
+	windows := buildOutdoorWindows(dayparts)
+	var notes []string
+	if windows.Best != nil {
+		notes = append(notes, fmt.Sprintf("Best outdoor window: %s (%s).", titleWord(windows.Best.Daypart), strings.Join(windows.Best.Reasons, ", ")))
+	}
+	if windows.Worst != nil && (windows.Best == nil || windows.Worst.Daypart != windows.Best.Daypart) {
+		notes = append(notes, fmt.Sprintf("Toughest outdoor window: %s (%s).", titleWord(windows.Worst.Daypart), strings.Join(windows.Worst.Reasons, ", ")))
+	}
+	return appendUnique(nil, notes...)
+}
+
 func readinessNotes(daypart forecast.DaypartSummary) []string {
 	notes := []string{}
 	if daypart.MaxPrecipitationProbability != nil && daypart.MaxPrecipitationProbability.Value >= 50 {
@@ -104,6 +181,27 @@ func readinessNotes(daypart forecast.DaypartSummary) []string {
 	return appendUnique(nil, notes...)
 }
 
+func lateDayWatchNotes(daypart forecast.DaypartSummary) []string {
+	notes := []string{}
+	prefix := titleWord(daypart.Name)
+	if prefix == "" {
+		prefix = "Late-day"
+	}
+	if daypart.MaxPrecipitationProbability != nil && daypart.MaxPrecipitationProbability.Value >= 30 {
+		notes = append(notes, fmt.Sprintf("%s precipitation timing may shift; current peak is near %.0f%%.", prefix, daypart.MaxPrecipitationProbability.Value))
+	}
+	if daypart.PeakWindGust != nil && daypart.PeakWindGust.Value >= 30 {
+		notes = append(notes, fmt.Sprintf("%s gusts may reach %.0f mph.", prefix, daypart.PeakWindGust.Value))
+	}
+	if daypart.Indicators.Snow || daypart.Indicators.Ice {
+		notes = append(notes, prefix+" wintry weather could affect late-day travel.")
+	}
+	if len(daypart.AlertOverlaps) > 0 {
+		notes = append(notes, prefix+" alert timing could affect late-day plans.")
+	}
+	return appendUnique(nil, notes...)
+}
+
 func concernNotes(daypart forecast.DaypartSummary) []string {
 	notes := []string{}
 	prefix := titleWord(daypart.Name)

internal/briefing/today_planning_module.go

@@ -0,0 +1,26 @@
+package briefing
+
+import "gitea.maximumdirect.net/eric/weatherreporter/internal/module"
+
+type TodayPlanningModule struct {
+	MorningReadiness             []string `json:"morning_readiness,omitempty"`
+	CommuteSchoolWorkdayConcerns []string `json:"commute_school_workday_concerns,omitempty"`
+	OutdoorPlanning              []string `json:"outdoor_planning,omitempty"`
+	LateDayChangeWatch           []string `json:"late_day_change_watch,omitempty"`
+}
+
+func buildTodayPlanningModule(ctx ModuleContext, _ any) (*module.Output, error) {
+	summary := ctx.Derived.FirstDailySummary()
+	if summary == nil {
+		return &module.Output{ID: module.TodayPlanning, StanzaName: "today_planning", Value: TodayPlanningModule{}}, nil
+	}
+	planning := buildTodayPlanning(summary)
+	value := TodayPlanningModule{}
+	if planning != nil {
+		value.MorningReadiness = append([]string(nil), planning.MorningReadiness...)
+		value.CommuteSchoolWorkdayConcerns = append([]string(nil), planning.CommuteSchoolWorkdayConcerns...)
+		value.OutdoorPlanning = append([]string(nil), planning.OutdoorPlanning...)
+		value.LateDayChangeWatch = append([]string(nil), planning.LateDayChangeWatch...)
+	}
+	return &module.Output{ID: module.TodayPlanning, StanzaName: "today_planning", Value: value}, nil
+}

internal/cli/output.go

@@ -0,0 +1,75 @@
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/app"
+)
+
+type outputOptions struct {
+	Quiet bool
+}
+
+func writeActionResult(stdout, stderr io.Writer, value any, opts outputOptions, writeStatus func(io.Writer)) error {
+	if opts.Quiet {
+		return nil
+	}
+	if writeStatus != nil && stderr != nil {
+		writeStatus(stderr)
+	}
+	return writeJSON(stdout, value)
+}
+
+func writeJSON(stdout io.Writer, value any) error {
+	encoder := json.NewEncoder(stdout)
+	encoder.SetIndent("", "  ")
+	return encoder.Encode(value)
+}
+
+func writeBatchStatus(stderr io.Writer, result *app.BatchResult) {
+	if stderr == nil || result == nil {
+		return
+	}
+	for _, item := range result.Reports {
+		notificationFields := ""
+		if item.NotificationStatus != "" {
+			notificationFields += fmt.Sprintf(" notificationStatus=%q", item.NotificationStatus)
+		}
+		if item.NotificationRunID != "" {
+			notificationFields += fmt.Sprintf(" notificationRunId=%q", item.NotificationRunID)
+		}
+		if item.NotificationError != "" {
+			notificationFields += fmt.Sprintf(" notificationError=%q", item.NotificationError)
+		}
+		if item.Status == "failed" {
+			_, _ = fmt.Fprintf(stderr, "report=%s status=failed error=%q%s\n", item.ReportID, item.Error, notificationFields)
+			continue
+		}
+		_, _ = fmt.Fprintf(stderr, "report=%s status=succeeded output=%q%s\n", item.ReportID, item.OutputPath, notificationFields)
+	}
+	if result.Notification != nil {
+		_, _ = fmt.Fprintf(stderr, "batchNotification status=%q", result.Notification.Status)
+		if result.Notification.Reason != "" {
+			_, _ = fmt.Fprintf(stderr, " reason=%q", result.Notification.Reason)
+		}
+		if result.Notification.RunID != "" {
+			_, _ = fmt.Fprintf(stderr, " runId=%q", result.Notification.RunID)
+		}
+		if result.Notification.PipelineID != "" {
+			_, _ = fmt.Fprintf(stderr, " pipelineId=%q", result.Notification.PipelineID)
+		}
+		if result.Notification.BundleID != "" {
+			_, _ = fmt.Fprintf(stderr, " bundleId=%q", result.Notification.BundleID)
+		}
+		if result.Notification.Path != "" {
+			_, _ = fmt.Fprintf(stderr, " path=%q", result.Notification.Path)
+		}
+		if result.Notification.Error != "" {
+			_, _ = fmt.Fprintf(stderr, " error=%q", result.Notification.Error)
+		}
+		_, _ = fmt.Fprintln(stderr)
+	}
+	_, _ = fmt.Fprintf(stderr, "batch=%s total=%d succeeded=%d failed=%d\n", result.Batch, result.Total, result.Succeeded, result.Failed)
+}

internal/cli/output_test.go

@@ -0,0 +1,59 @@
+package cli
+
+import (
+	"bytes"
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestWriteActionResultWritesStatusBeforeJSON(t *testing.T) {
+	var output bytes.Buffer
+
+	err := writeActionResult(&output, &output, map[string]string{"status": "succeeded"}, outputOptions{}, func(w io.Writer) {
+		_, _ = w.Write([]byte("status line\n"))
+	})
+	if err != nil {
+		t.Fatalf("writeActionResult() error = %v", err)
+	}
+	if !strings.HasPrefix(output.String(), "status line\n") {
+		t.Fatalf("output = %q, want status before JSON", output.String())
+	}
+	if !strings.Contains(output.String(), `"status": "succeeded"`) {
+		t.Fatalf("output missing JSON result:\n%s", output.String())
+	}
+}
+
+func TestWriteActionResultQuietSuppressesOutput(t *testing.T) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+
+	err := writeActionResult(&stdout, &stderr, map[string]string{"status": "succeeded"}, outputOptions{Quiet: true}, func(w io.Writer) {
+		_, _ = w.Write([]byte("status line\n"))
+	})
+	if err != nil {
+		t.Fatalf("writeActionResult() error = %v", err)
+	}
+	if stdout.Len() != 0 || stderr.Len() != 0 {
+		t.Fatalf("stdout/stderr = %q/%q, want no output", stdout.String(), stderr.String())
+	}
+}
+
+func TestWriteActionResultToleratesNilStderr(t *testing.T) {
+	var stdout bytes.Buffer
+	statusCalled := false
+
+	err := writeActionResult(&stdout, nil, map[string]string{"status": "succeeded"}, outputOptions{}, func(w io.Writer) {
+		statusCalled = true
+		_, _ = w.Write([]byte("status line\n"))
+	})
+	if err != nil {
+		t.Fatalf("writeActionResult() error = %v", err)
+	}
+	if statusCalled {
+		t.Fatal("status writer was called with nil stderr")
+	}
+	if !strings.Contains(stdout.String(), `"status": "succeeded"`) {
+		t.Fatalf("stdout missing JSON result:\n%s", stdout.String())
+	}
+}

internal/cli/result.go

@@ -0,0 +1,162 @@
+package cli
+
+import (
+	"time"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/app"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+)
+
+const (
+	commandGenerate = "generate"
+	commandRun      = "run"
+
+	summaryStatusSucceeded = "succeeded"
+	summaryStatusFailed    = "failed"
+)
+
+type generateSummary struct {
+	Command                 string                       `json:"command"`
+	ReportID                report.ID                    `json:"reportId"`
+	ReportName              string                       `json:"reportName"`
+	PromptID                string                       `json:"promptId"`
+	RunID                   string                       `json:"runId"`
+	Status                  string                       `json:"status"`
+	GeneratedAt             time.Time                    `json:"generatedAt"`
+	ValidPeriod             timeutil.Period              `json:"validPeriod"`
+	ReportPath              string                       `json:"reportPath,omitempty"`
+	OutputPath              string                       `json:"outputPath,omitempty"`
+	MetadataPath            string                       `json:"metadataPath,omitempty"`
+	DataPackagePath         string                       `json:"dataPackagePath,omitempty"`
+	PreflightPath           string                       `json:"preflightPath,omitempty"`
+	GeneratedTextRawPath    string                       `json:"generatedTextRawPath,omitempty"`
+	GeneratedTextResultPath string                       `json:"generatedTextResultPath,omitempty"`
+	GeneratedTextPath       string                       `json:"generatedTextPath,omitempty"`
+	RenderContextPath       string                       `json:"renderContextPath,omitempty"`
+	NotificationPath        string                       `json:"notificationPath,omitempty"`
+	Notification            *generateNotificationSummary `json:"notification,omitempty"`
+	Error                   string                       `json:"error,omitempty"`
+}
+
+type generateNotificationSummary struct {
+	Status         string     `json:"status,omitempty"`
+	UploadStatus   string     `json:"uploadStatus,omitempty"`
+	StatusError    string     `json:"statusError,omitempty"`
+	RunID          string     `json:"runId,omitempty"`
+	PipelineID     string     `json:"pipelineId,omitempty"`
+	BundleID       string     `json:"bundleId,omitempty"`
+	IdempotencyKey string     `json:"idempotencyKey,omitempty"`
+	AcceptedAt     *time.Time `json:"acceptedAt,omitempty"`
+	StartedAt      *time.Time `json:"startedAt,omitempty"`
+	FinishedAt     *time.Time `json:"finishedAt,omitempty"`
+	Error          string     `json:"error,omitempty"`
+}
+
+type batchSummary struct {
+	Command      string                       `json:"command"`
+	Batch        app.BatchKind                `json:"batch"`
+	Status       string                       `json:"status"`
+	StartedAt    time.Time                    `json:"startedAt"`
+	FinishedAt   time.Time                    `json:"finishedAt"`
+	Total        int                          `json:"total"`
+	Succeeded    int                          `json:"succeeded"`
+	Failed       int                          `json:"failed"`
+	Notification *app.BatchNotificationResult `json:"notification,omitempty"`
+	Reports      []app.BatchReportResult      `json:"reports"`
+	Error        string                       `json:"error,omitempty"`
+}
+
+func newGenerateSummary(result *app.ReportResult, err error) generateSummary {
+	summary := generateSummary{Command: commandGenerate}
+	if result == nil {
+		return summary
+	}
+
+	metadata := result.Metadata
+	summary.ReportID = metadata.ReportID
+	summary.ReportName = reportName(metadata.ReportID)
+	summary.PromptID = metadata.PromptID
+	summary.RunID = metadata.RunID
+	summary.Status = summaryStatusSucceeded
+	summary.GeneratedAt = metadata.GeneratedAt
+	summary.ValidPeriod = metadata.ValidPeriod
+	summary.ReportPath = result.ReportPath
+	summary.OutputPath = result.OutputPath
+	summary.MetadataPath = result.MetadataPath
+	summary.DataPackagePath = result.DataPackagePath
+	summary.PreflightPath = result.PreflightPath
+	summary.GeneratedTextRawPath = result.GeneratedTextRawPath
+	summary.GeneratedTextResultPath = result.GeneratedTextResultPath
+	summary.GeneratedTextPath = result.GeneratedTextPath
+	summary.RenderContextPath = result.RenderContextPath
+	summary.NotificationPath = result.NotificationPath
+	summary.Notification = newGenerateNotificationSummary(result.Notification)
+	if err != nil {
+		summary.Status = summaryStatusFailed
+		summary.Error = err.Error()
+	}
+	return summary
+}
+
+func newGenerateNotificationSummary(result *app.NotificationResult) *generateNotificationSummary {
+	if result == nil {
+		return nil
+	}
+	summary := &generateNotificationSummary{
+		Status:         result.Status,
+		UploadStatus:   result.UploadStatus,
+		StatusError:    result.StatusError,
+		RunID:          result.RunID,
+		PipelineID:     result.PipelineID,
+		BundleID:       result.BundleID,
+		IdempotencyKey: result.IdempotencyKey,
+		StartedAt:      result.StartedAt,
+		FinishedAt:     result.FinishedAt,
+		Error:          result.Error,
+	}
+	if !result.AcceptedAt.IsZero() {
+		acceptedAt := result.AcceptedAt
+		summary.AcceptedAt = &acceptedAt
+	}
+	return summary
+}
+
+func newBatchSummary(result *app.BatchResult) batchSummary {
+	summary := batchSummary{Command: commandRun}
+	if result == nil {
+		return summary
+	}
+
+	summary.Batch = result.Batch
+	summary.Status = batchSummaryStatus(result)
+	summary.StartedAt = result.StartedAt
+	summary.FinishedAt = result.FinishedAt
+	summary.Total = result.Total
+	summary.Succeeded = result.Succeeded
+	summary.Failed = result.Failed
+	summary.Notification = result.Notification
+	summary.Reports = append([]app.BatchReportResult(nil), result.Reports...)
+	if summary.Status == summaryStatusFailed {
+		summary.Error = app.BatchError{Result: result}.Error()
+	}
+	return summary
+}
+
+func batchSummaryStatus(result *app.BatchResult) string {
+	if result == nil {
+		return ""
+	}
+	if result.Failed > 0 || (result.Notification != nil && result.Notification.Status == summaryStatusFailed) {
+		return summaryStatusFailed
+	}
+	return summaryStatusSucceeded
+}
+
+func reportName(id report.ID) string {
+	definition, err := report.DefaultRegistry().Lookup(id)
+	if err != nil {
+		return string(id)
+	}
+	return definition.Name
+}

internal/cli/result_test.go

@@ -0,0 +1,231 @@
+package cli
+
+import (
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/app"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/state"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+)
+
+func TestNewGenerateSummaryForGeneratedTextReport(t *testing.T) {
+	generatedAt := time.Date(2026, 5, 29, 13, 30, 0, 0, time.UTC)
+	acceptedAt := generatedAt.Add(time.Minute)
+	startedAt := acceptedAt.Add(time.Minute)
+	finishedAt := startedAt.Add(time.Minute)
+	result := &app.ReportResult{
+		DataPackagePath:         "/runs/hourly/data_package.yaml",
+		PreflightPath:           "/runs/hourly/preflight.json",
+		ReportPath:              "/runs/hourly/report.md",
+		OutputPath:              "/copies/hourly.md",
+		MetadataPath:            "/runs/hourly/metadata.json",
+		GeneratedTextRawPath:    "/runs/hourly/generated_text_raw.json",
+		GeneratedTextResultPath: "/runs/hourly/generated_text_result.json",
+		GeneratedTextPath:       "/runs/hourly/generated_text.json",
+		RenderContextPath:       "/runs/hourly/render_context.json",
+		NotificationPath:        "/runs/hourly/notification.json",
+		Metadata: state.Metadata{
+			ReportID:    report.Hourly,
+			PromptID:    "weather.hourly_generated_text",
+			RunID:       "20260529T133000Z_hourly",
+			GeneratedAt: generatedAt,
+			ValidPeriod: testSummaryPeriod(generatedAt),
+		},
+		Notification: &app.NotificationResult{
+			Status:         "succeeded",
+			UploadStatus:   "accepted",
+			RunID:          "distributor-run",
+			PipelineID:     "weatherreporter.hourly",
+			BundleID:       "weatherreporter.home.hourly",
+			IdempotencyKey: "weatherreporter.home.hourly.20260529T133000Z_hourly",
+			AcceptedAt:     acceptedAt,
+			StartedAt:      &startedAt,
+			FinishedAt:     &finishedAt,
+			Report:         []byte(`{"actions":[{"action":"replace_older"}]}`),
+		},
+	}
+
+	summary := newGenerateSummary(result, nil)
+
+	if summary.Command != "generate" || summary.Status != "succeeded" {
+		t.Fatalf("summary command/status = %q/%q, want generate/succeeded", summary.Command, summary.Status)
+	}
+	if summary.ReportID != report.Hourly || summary.ReportName != "Hourly Report" || summary.PromptID != "weather.hourly_generated_text" || summary.RunID != "20260529T133000Z_hourly" {
+		t.Fatalf("summary identity = %#v, want hourly report identity", summary)
+	}
+	if summary.GeneratedTextRawPath == "" || summary.GeneratedTextResultPath == "" || summary.GeneratedTextPath == "" || summary.RenderContextPath == "" {
+		t.Fatalf("generated-text paths = %#v, want generated-text artifact paths", summary)
+	}
+	if summary.Notification == nil || summary.Notification.RunID != "distributor-run" || summary.Notification.AcceptedAt == nil || !summary.Notification.AcceptedAt.Equal(acceptedAt) {
+		t.Fatalf("notification = %#v, want summarized distributor result", summary.Notification)
+	}
+	data, err := json.Marshal(summary)
+	if err != nil {
+		t.Fatalf("Marshal() error = %v", err)
+	}
+	if strings.Contains(string(data), "replace_older") || strings.Contains(string(data), "actions") {
+		t.Fatalf("summary JSON includes raw distributor report payload:\n%s", string(data))
+	}
+}
+
+func TestNewGenerateSummaryForMarkdownReportOmitsGeneratedTextAndNotification(t *testing.T) {
+	generatedAt := time.Date(2026, 5, 29, 13, 30, 0, 0, time.UTC)
+	result := &app.ReportResult{
+		DataPackagePath: "/runs/three-day/data_package.yaml",
+		PreflightPath:   "/runs/three-day/preflight.json",
+		ReportPath:      "/runs/three-day/report.md",
+		OutputPath:      "/copies/three-day.md",
+		MetadataPath:    "/runs/three-day/metadata.json",
+		Metadata: state.Metadata{
+			ReportID:    report.ThreeDay,
+			PromptID:    "weather.three_day_outlook",
+			RunID:       "20260529T133000Z_three_day",
+			GeneratedAt: generatedAt,
+			ValidPeriod: testSummaryPeriod(generatedAt),
+		},
+	}
+
+	summary := newGenerateSummary(result, nil)
+
+	if summary.ReportID != report.ThreeDay || summary.ReportName != "3-Day Outlook" || summary.Status != "succeeded" {
+		t.Fatalf("summary = %#v, want successful 3-day summary", summary)
+	}
+	if summary.Notification != nil || summary.NotificationPath != "" {
+		t.Fatalf("notification summary/path = %#v/%q, want omitted", summary.Notification, summary.NotificationPath)
+	}
+	data, err := json.Marshal(summary)
+	if err != nil {
+		t.Fatalf("Marshal() error = %v", err)
+	}
+	for _, omitted := range []string{"generatedTextRawPath", "generatedTextResultPath", "generatedTextPath", "renderContextPath", "notification"} {
+		if strings.Contains(string(data), omitted) {
+			t.Fatalf("summary JSON contains %q, want omitted:\n%s", omitted, string(data))
+		}
+	}
+}
+
+func TestNewGenerateSummaryForNotificationFailure(t *testing.T) {
+	generatedAt := time.Date(2026, 5, 29, 13, 30, 0, 0, time.UTC)
+	result := &app.ReportResult{
+		DataPackagePath:  "/runs/hourly/data_package.yaml",
+		PreflightPath:    "/runs/hourly/preflight.json",
+		ReportPath:       "/runs/hourly/report.md",
+		OutputPath:       "/copies/hourly.md",
+		MetadataPath:     "/runs/hourly/metadata.json",
+		NotificationPath: "/runs/hourly/notification.json",
+		Metadata: state.Metadata{
+			ReportID:    report.Hourly,
+			PromptID:    "weather.hourly_generated_text",
+			RunID:       "20260529T133000Z_hourly",
+			GeneratedAt: generatedAt,
+			ValidPeriod: testSummaryPeriod(generatedAt),
+		},
+	}
+	err := errors.New(`notify report "hourly" run "20260529T133000Z_hourly": upload rejected`)
+
+	summary := newGenerateSummary(result, err)
+
+	if summary.Status != "failed" || summary.Error != err.Error() {
+		t.Fatalf("status/error = %q/%q, want failed notification error", summary.Status, summary.Error)
+	}
+	if summary.NotificationPath != "/runs/hourly/notification.json" || summary.ReportPath == "" || summary.MetadataPath == "" {
+		t.Fatalf("artifact paths = report %q metadata %q notification %q, want inspectable paths", summary.ReportPath, summary.MetadataPath, summary.NotificationPath)
+	}
+}
+
+func TestNewBatchSummaryStatusDerivation(t *testing.T) {
+	startedAt := time.Date(2026, 5, 29, 12, 0, 0, 0, time.UTC)
+	finishedAt := startedAt.Add(2 * time.Minute)
+	tests := []struct {
+		name       string
+		result     *app.BatchResult
+		wantStatus string
+		wantError  string
+	}{
+		{
+			name: "success",
+			result: &app.BatchResult{
+				Batch:      app.BatchMorning,
+				StartedAt:  startedAt,
+				FinishedAt: finishedAt,
+				Total:      1,
+				Succeeded:  1,
+				Reports:    []app.BatchReportResult{{ReportID: report.Today, Status: "succeeded"}},
+			},
+			wantStatus: "succeeded",
+		},
+		{
+			name: "report failure",
+			result: &app.BatchResult{
+				Batch:     app.BatchMorning,
+				Total:     2,
+				Succeeded: 1,
+				Failed:    1,
+				Reports: []app.BatchReportResult{
+					{ReportID: report.Today, Status: "succeeded"},
+					{ReportID: report.Tomorrow, Status: "failed", Error: "render failed"},
+				},
+			},
+			wantStatus: "failed",
+			wantError:  "batch morning failed: 1 of 2 reports failed",
+		},
+		{
+			name: "skipped notification",
+			result: &app.BatchResult{
+				Batch:     app.BatchEvening,
+				Total:     2,
+				Succeeded: 1,
+				Failed:    1,
+				Reports:   []app.BatchReportResult{{ReportID: report.Tomorrow, Status: "failed"}},
+				Notification: &app.BatchNotificationResult{
+					Status: "skipped",
+					Reason: "one or more reports failed",
+				},
+			},
+			wantStatus: "failed",
+			wantError:  "batch evening failed: 1 of 2 reports failed",
+		},
+		{
+			name: "failed notification",
+			result: &app.BatchResult{
+				Batch:     app.BatchEvening,
+				Total:     1,
+				Succeeded: 1,
+				Reports:   []app.BatchReportResult{{ReportID: report.Tomorrow, Status: "succeeded"}},
+				Notification: &app.BatchNotificationResult{
+					Status: "failed",
+					Error:  "notify batch evening: upload rejected",
+				},
+			},
+			wantStatus: "failed",
+			wantError:  "batch evening notification failed: notify batch evening: upload rejected",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			summary := newBatchSummary(tt.result)
+			if summary.Command != "run" || summary.Status != tt.wantStatus {
+				t.Fatalf("command/status = %q/%q, want run/%s", summary.Command, summary.Status, tt.wantStatus)
+			}
+			if summary.Error != tt.wantError {
+				t.Fatalf("error = %q, want %q", summary.Error, tt.wantError)
+			}
+			if len(summary.Reports) != len(tt.result.Reports) {
+				t.Fatalf("reports = %#v, want copied report list", summary.Reports)
+			}
+		})
+	}
+}
+
+func testSummaryPeriod(start time.Time) timeutil.Period {
+	return timeutil.Period{
+		Start: start,
+		End:   start.Add(6 * time.Hour),
+	}
+}

internal/cli/root.go

@@ -2,7 +2,6 @@ package cli
 
 import (
 	"context"
-	"encoding/json"
 	"flag"
 	"fmt"
 	"io"
@@ -17,14 +16,15 @@ const helpText = `weatherreporter prepares weather reports from normalized forec
 
 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 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
-  weatherreporter run morning [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH]
-  weatherreporter run evening [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH]
+  weatherreporter generate daily --date YYYY-MM-DD [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+  weatherreporter generate today [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--date YYYY-MM-DD] [--quiet]
+  weatherreporter generate tomorrow [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+  weatherreporter generate hourly [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+  weatherreporter generate three-day [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+  weatherreporter generate weekend [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet]
+  weatherreporter generate storm [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--quiet] --start TIME --end TIME
+  weatherreporter run morning [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH] [--quiet]
+  weatherreporter run evening [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH] [--quiet]
   weatherreporter inspect reports [--config PATH] [--limit N]
   weatherreporter inspect metadata [--config PATH] RUN_ID
   weatherreporter inspect modules [--config PATH] RUN_ID
@@ -39,6 +39,7 @@ Options:
   --tz NAME        Override weather API timezone.
   --out PATH       Write an extra Markdown report copy where supported by the generate command.
   --out-dir PATH   Write extra Markdown report copies for run commands.
+  --quiet          Suppress successful generate and run output.
 `
 
 type Runner struct {
@@ -50,7 +51,6 @@ func Run(ctx context.Context, args []string, stdout io.Writer, stderr io.Writer)
 }
 
 func (r Runner) Run(ctx context.Context, args []string, stdout io.Writer, stderr io.Writer) error {
-	_ = stderr
 	if r.Clock == nil {
 		r.Clock = timeutil.SystemClock{}
 	}
@@ -61,23 +61,32 @@ func (r Runner) Run(ctx context.Context, args []string, stdout io.Writer, stderr
 
 	switch args[0] {
 	case "generate":
-		req, err := r.resolveGenerate(args[1:])
+		req, opts, err := r.resolveGenerateAction(args[1:])
 		if err != nil {
 			return err
 		}
-		return app.Generate(ctx, req)
+		result, err := app.GenerateDetailed(ctx, req)
+		if result != nil {
+			summary := newGenerateSummary(result, err)
+			if encodeErr := writeActionResult(stdout, stderr, summary, outputOptions{Quiet: opts.Quiet}, nil); encodeErr != nil {
+				return encodeErr
+			}
+		}
+		return err
 	case "run":
-		req, err := r.resolveRun(args[1:])
+		req, opts, err := r.resolveRunAction(args[1:])
 		if err != nil {
 			return err
 		}
 		result, err := app.RunBatchDetailed(ctx, req)
 		if result != nil {
-			writeRunLogs(stderr, result)
-			if encodeErr := writeJSON(stdout, result); encodeErr != nil {
+			summary := newBatchSummary(result)
+			if encodeErr := writeActionResult(stdout, stderr, summary, outputOptions{Quiet: opts.Quiet}, func(w io.Writer) {
+				writeBatchStatus(w, result)
+			}); encodeErr != nil {
 				return encodeErr
 			}
-			if result.Failed > 0 {
+			if summary.Status == summaryStatusFailed {
 				return app.BatchError{Result: result}
 			}
 		}
@@ -95,6 +104,7 @@ type commonOptions struct {
 	Timezone   string
 	Output     string
 	OutputDir  string
+	Quiet      bool
 }
 
 type generateOptions struct {
@@ -180,20 +190,25 @@ func runInspectRunCommand(ctx context.Context, stdout io.Writer, command inspect
 }
 
 func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
+	req, _, err := r.resolveGenerateAction(args)
+	return req, err
+}
+
+func (r Runner) resolveGenerateAction(args []string) (app.GenerateRequest, commonOptions, error) {
 	if r.Clock == nil {
 		r.Clock = timeutil.SystemClock{}
 	}
 	if len(args) == 0 {
-		return app.GenerateRequest{}, fmt.Errorf("generate requires a report name")
+		return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("generate requires a report name")
 	}
-	reportKind, ok := reportKind(args[0])
-	if !ok {
-		return app.GenerateRequest{}, fmt.Errorf("unknown generate report %q", args[0])
+	if _, err := report.IDForCommandName(args[0]); err != nil {
+		return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("unknown generate report %q", args[0])
 	}
+	reportKind := app.ReportKind(args[0])
 
 	opts, err := parseGenerateFlags(reportKind, args[1:])
 	if err != nil {
-		return app.GenerateRequest{}, err
+		return app.GenerateRequest{}, commonOptions{}, err
 	}
 	cfg, err := config.Load(config.LoadOptions{
 		Path:     opts.ConfigPath,
@@ -201,11 +216,11 @@ func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
 		Timezone: opts.Timezone,
 	})
 	if err != nil {
-		return app.GenerateRequest{}, err
+		return app.GenerateRequest{}, commonOptions{}, err
 	}
 	location, err := timeutil.LoadLocation(cfg.WeatherAPI.Timezone)
 	if err != nil {
-		return app.GenerateRequest{}, err
+		return app.GenerateRequest{}, commonOptions{}, err
 	}
 
 	req := app.GenerateRequest{
@@ -217,46 +232,59 @@ func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
 
 	switch reportKind {
 	case app.ReportDaily:
+		if opts.Date == "" {
+			return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("generate daily requires --date YYYY-MM-DD")
+		}
+		req.Date, err = timeutil.ParseLocalDate(opts.Date, location)
+		if err != nil {
+			return app.GenerateRequest{}, commonOptions{}, err
+		}
+	case app.ReportToday:
 		if opts.Date == "" {
 			req.Date = timeutil.LocalDate(r.Clock.Now(), location)
 		} else {
 			req.Date, err = timeutil.ParseLocalDate(opts.Date, location)
 			if err != nil {
-				return app.GenerateRequest{}, err
+				return app.GenerateRequest{}, commonOptions{}, err
 			}
 		}
 	case app.ReportStorm:
 		if opts.Start == "" {
-			return app.GenerateRequest{}, fmt.Errorf("generate storm requires --start")
+			return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("generate storm requires --start")
 		}
 		if opts.End == "" {
-			return app.GenerateRequest{}, fmt.Errorf("generate storm requires --end")
+			return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("generate storm requires --end")
 		}
 		period, err := report.ParseStormPeriod(opts.Start, opts.End, location)
 		if err != nil {
-			return app.GenerateRequest{}, err
+			return app.GenerateRequest{}, commonOptions{}, err
 		}
 		req.StormStart = period.Start
 		req.StormEnd = period.End
 	}
 
-	return req, nil
+	return req, opts.commonOptions, nil
 }
 
 func (r Runner) resolveRun(args []string) (app.BatchRequest, error) {
+	req, _, err := r.resolveRunAction(args)
+	return req, err
+}
+
+func (r Runner) resolveRunAction(args []string) (app.BatchRequest, commonOptions, error) {
 	if r.Clock == nil {
 		r.Clock = timeutil.SystemClock{}
 	}
 	if len(args) == 0 {
-		return app.BatchRequest{}, fmt.Errorf("run requires a batch name")
+		return app.BatchRequest{}, commonOptions{}, fmt.Errorf("run requires a batch name")
 	}
-	batch, ok := batchKind(args[0])
-	if !ok {
-		return app.BatchRequest{}, fmt.Errorf("unknown run batch %q", args[0])
+	if _, err := report.BatchForCommandName(args[0]); err != nil {
+		return app.BatchRequest{}, commonOptions{}, fmt.Errorf("unknown run batch %q", args[0])
 	}
+	batch := app.BatchKind(args[0])
 	opts, err := parseRunFlags(args[1:])
 	if err != nil {
-		return app.BatchRequest{}, err
+		return app.BatchRequest{}, commonOptions{}, err
 	}
 	cfg, err := config.Load(config.LoadOptions{
 		Path:     opts.ConfigPath,
@@ -264,9 +292,9 @@ func (r Runner) resolveRun(args []string) (app.BatchRequest, error) {
 		Timezone: opts.Timezone,
 	})
 	if err != nil {
-		return app.BatchRequest{}, err
+		return app.BatchRequest{}, commonOptions{}, err
 	}
-	return app.BatchRequest{Config: cfg, Batch: batch, Now: r.Clock.Now(), OutputDir: opts.OutputDir}, nil
+	return app.BatchRequest{Config: cfg, Batch: batch, Now: r.Clock.Now(), OutputDir: opts.OutputDir}, opts, nil
 }
 
 func resolveRun(args []string) (app.BatchRequest, error) {
@@ -278,7 +306,8 @@ func parseGenerateFlags(report app.ReportKind, args []string) (generateOptions,
 	fs.SetOutput(io.Discard)
 	opts := generateOptions{}
 	addCommonFlags(fs, &opts.commonOptions, true)
-	if report == app.ReportDaily {
+	fs.BoolVar(&opts.Quiet, "quiet", false, "suppress successful action output")
+	if report == app.ReportDaily || report == app.ReportToday {
 		fs.StringVar(&opts.Date, "date", "", "report date in YYYY-MM-DD")
 	}
 	if report == app.ReportStorm {
@@ -300,6 +329,7 @@ func parseRunFlags(args []string) (commonOptions, error) {
 	opts := commonOptions{}
 	addCommonFlags(fs, &opts, false)
 	fs.StringVar(&opts.OutputDir, "out-dir", "", "extra Markdown report copy directory")
+	fs.BoolVar(&opts.Quiet, "quiet", false, "suppress successful action output")
 	if err := fs.Parse(args); err != nil {
 		return commonOptions{}, err
 	}
@@ -342,36 +372,6 @@ func parseInspectRunFlags(command string, args []string) (inspectOptions, error)
 	return opts, nil
 }
 
-func writeJSON(stdout io.Writer, value any) error {
-	encoder := json.NewEncoder(stdout)
-	encoder.SetIndent("", "  ")
-	return encoder.Encode(value)
-}
-
-func writeRunLogs(stderr io.Writer, result *app.BatchResult) {
-	if stderr == nil || result == nil {
-		return
-	}
-	for _, item := range result.Reports {
-		notificationFields := ""
-		if item.NotificationStatus != "" {
-			notificationFields += fmt.Sprintf(" notificationStatus=%q", item.NotificationStatus)
-		}
-		if item.NotificationRunID != "" {
-			notificationFields += fmt.Sprintf(" notificationRunId=%q", item.NotificationRunID)
-		}
-		if item.NotificationError != "" {
-			notificationFields += fmt.Sprintf(" notificationError=%q", item.NotificationError)
-		}
-		if item.Status == "failed" {
-			_, _ = fmt.Fprintf(stderr, "report=%s status=failed error=%q%s\n", item.ReportID, item.Error, notificationFields)
-			continue
-		}
-		_, _ = fmt.Fprintf(stderr, "report=%s status=succeeded output=%q%s\n", item.ReportID, item.OutputPath, notificationFields)
-	}
-	_, _ = fmt.Fprintf(stderr, "batch=%s total=%d succeeded=%d failed=%d\n", result.Batch, result.Total, result.Succeeded, result.Failed)
-}
-
 func addCommonFlags(fs *flag.FlagSet, opts *commonOptions, includeOutput bool) {
 	fs.StringVar(&opts.ConfigPath, "config", "", "configuration file path")
 	fs.StringVar(&opts.Units, "units", "", "weather API units")
@@ -380,33 +380,3 @@ func addCommonFlags(fs *flag.FlagSet, opts *commonOptions, includeOutput bool) {
 		fs.StringVar(&opts.Output, "out", "", "extra Markdown report copy path")
 	}
 }
-
-func reportKind(value string) (app.ReportKind, bool) {
-	switch value {
-	case string(app.ReportDaily):
-		return app.ReportDaily, true
-	case string(app.ReportTomorrow):
-		return app.ReportTomorrow, true
-	case string(app.ReportHourly):
-		return app.ReportHourly, true
-	case string(app.ReportThreeDay):
-		return app.ReportThreeDay, true
-	case string(app.ReportWeekend):
-		return app.ReportWeekend, true
-	case string(app.ReportStorm):
-		return app.ReportStorm, true
-	default:
-		return "", false
-	}
-}
-
-func batchKind(value string) (app.BatchKind, bool) {
-	switch value {
-	case string(app.BatchMorning):
-		return app.BatchMorning, true
-	case string(app.BatchEvening):
-		return app.BatchEvening, true
-	default:
-		return "", false
-	}
-}

internal/collect/collect.go

@@ -0,0 +1,31 @@
+// Package collect owns upstream weather source collection for application use.
+package collect
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/weatherapi"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
+)
+
+type Request struct {
+	Config config.Config
+}
+
+type Result struct {
+	Bundle *weatherdata.Bundle
+}
+
+func Run(ctx context.Context, req Request) (*Result, error) {
+	client, err := weatherapi.New(req.Config)
+	if err != nil {
+		return nil, fmt.Errorf("prepare weather collection: %w", err)
+	}
+	bundle, err := client.FetchBundle(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("collect weather bundle: %w", err)
+	}
+	return &Result{Bundle: bundle}, nil
+}

internal/collect/collect_test.go

@@ -0,0 +1,99 @@
+package collect
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+)
+
+func TestRunFetchesBundle(t *testing.T) {
+	server := collectionTestServer(t, nil)
+	defer server.Close()
+
+	cfg := config.Defaults()
+	cfg.WeatherAPI.BaseURL = server.URL + "/"
+
+	result, err := Run(context.Background(), Request{Config: cfg})
+	if err != nil {
+		t.Fatalf("Run() error = %v", err)
+	}
+	if result == nil || result.Bundle == nil {
+		t.Fatal("Run() result bundle = nil, want fetched bundle")
+	}
+	if result.Bundle.Hourly == nil {
+		t.Fatal("Hourly = nil, want fetched hourly forecast")
+	}
+	if result.Bundle.WeatherStory == nil || result.Bundle.WeatherStory.Title != "Several Chances for Rain Through Monday" {
+		t.Fatalf("WeatherStory = %#v, want fetched weather story", result.Bundle.WeatherStory)
+	}
+}
+
+func TestRunWrapsAdapterConstructionError(t *testing.T) {
+	cfg := config.Defaults()
+	cfg.WeatherAPI.BaseURL = ""
+	cfg.Secrets.Directory = "super-secret-directory"
+
+	_, err := Run(context.Background(), Request{Config: cfg})
+	if err == nil {
+		t.Fatal("Run() error = nil, want adapter construction error")
+	}
+	if !strings.Contains(err.Error(), "prepare weather collection") {
+		t.Fatalf("error = %q, want collection setup context", err.Error())
+	}
+	if strings.Contains(err.Error(), cfg.Secrets.Directory) {
+		t.Fatalf("error = %q, want no secret path leakage", err.Error())
+	}
+}
+
+func TestRunWrapsFetchError(t *testing.T) {
+	server := collectionTestServer(t, map[string]int{"/observations": http.StatusBadGateway})
+	defer server.Close()
+
+	cfg := config.Defaults()
+	cfg.WeatherAPI.BaseURL = server.URL + "/"
+
+	_, err := Run(context.Background(), Request{Config: cfg})
+	if err == nil {
+		t.Fatal("Run() error = nil, want fetch error")
+	}
+	if !strings.Contains(err.Error(), "collect weather bundle") {
+		t.Fatalf("error = %q, want collection fetch context", err.Error())
+	}
+	if !strings.Contains(err.Error(), "/observations") {
+		t.Fatalf("error = %q, want source endpoint context", err.Error())
+	}
+}
+
+func collectionTestServer(t *testing.T, statusByPath map[string]int) *httptest.Server {
+	t.Helper()
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if status := statusByPath[r.URL.Path]; status != 0 {
+			http.Error(w, "upstream failure", status)
+			return
+		}
+		switch r.URL.Path {
+		case "/observations":
+			_, _ = w.Write([]byte(`{"data":{"timestamp":"2026-05-29T14:00:00Z","conditionCode":3}}`))
+		case "/conditions/current":
+			_, _ = w.Write([]byte(`{"data":{"conditionText":"Clear"}}`))
+		case "/forecast/hourly":
+			_, _ = w.Write([]byte(`{"data":{"issuedAt":"2026-05-29T10:30:00-05:00","product":"hourly","periods":[{"startTime":"2026-05-29T13:00:00-05:00","endTime":"2026-05-29T14:00:00-05:00"}]}}`))
+		case "/forecast/narrative":
+			_, _ = w.Write([]byte(`{"data":{"issuedAt":"2026-05-29T10:30:00-05:00","product":"narrative","periods":[]}}`))
+		case "/alerts/active":
+			_, _ = w.Write([]byte(`{"data":{"alerts":[]}}`))
+		case "/discussion":
+			_, _ = w.Write([]byte(`{"data":{"product":"discussion","issuedAt":"2026-05-29T09:25:00-05:00","keyMessages":[],"shortTerm":{"qualifier":"(Short Term)","text":"Short-term AFD narrative for saved bundle."},"longTerm":{"qualifier":"(Long Term)","text":"Long-term AFD narrative for saved bundle."}}}`))
+		case "/weatherstories/latest":
+			_, _ = w.Write([]byte(`{"data":{"officeId":"LSX","startTime":"2026-05-30T08:46:00Z","endTime":"2026-05-31T11:00:00Z","updatedAt":"2026-05-30T09:00:34Z","title":"Several Chances for Rain Through Monday","description":"Scattered showers and thunderstorms remain possible.","altText":"Forecast weather story graphic.","priority":false,"order":1,"downloadUrl":"https://api.weather.gov/offices/LSX/weatherstories/download/test"}}`))
+		case "/outlooks/convective":
+			_, _ = w.Write([]byte(`{"data":{"asOf":"2026-05-29T16:00:00Z","outlooks":[],"discussions":[]}}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+}

internal/config/config.go

@@ -66,7 +66,14 @@ type DistributorNotifyConfig struct {
 	PipelineIDTemplate     string                       `yaml:"pipeline_id_template"`
 	BundleIDTemplate       string                       `yaml:"bundle_id_template"`
 	IdempotencyKeyTemplate string                       `yaml:"idempotency_key_template"`
-	ReportPathTemplates    []string            `yaml:"report_path_templates"`
+	Batch                  DistributorBatchNotifyConfig `yaml:"batch"`
+}
+
+type DistributorBatchNotifyConfig struct {
+	Enabled                bool   `yaml:"enabled"`
+	PipelineIDTemplate     string `yaml:"pipeline_id_template"`
+	BundleIDTemplate       string `yaml:"bundle_id_template"`
+	IdempotencyKeyTemplate string `yaml:"idempotency_key_template"`
 }
 
 type MissingSourceConfig struct {
@@ -106,9 +113,15 @@ type RecentChangeConfig struct {
 
 type ReportConfig struct {
 	DeterministicModules    []ModuleConfigItem      `yaml:"deterministic_modules"`
+	Distributor             ReportDistributorConfig `yaml:"distributor"`
 	deterministicModulesSet bool
 }
 
+type ReportDistributorConfig struct {
+	PathTemplates    []string `yaml:"path_templates"`
+	pathTemplatesSet bool
+}
+
 type ModuleConfigItem struct {
 	ID      module.ID `yaml:"id"`
 	Options any       `yaml:"options,omitempty"`
@@ -127,6 +140,10 @@ func (c *ReportConfig) UnmarshalYAML(value *yaml.Node) error {
 				return err
 			}
 			c.deterministicModulesSet = true
+		case "distributor":
+			if err := node.Decode(&c.Distributor); err != nil {
+				return err
+			}
 		default:
 			return fmt.Errorf("unknown report entry field %q", key)
 		}
@@ -134,6 +151,112 @@ func (c *ReportConfig) UnmarshalYAML(value *yaml.Node) error {
 	return nil
 }
 
+func (c *DistributorNotifyConfig) UnmarshalYAML(value *yaml.Node) error {
+	if value.Kind != yaml.MappingNode {
+		return fmt.Errorf("notify distributor entry must be a mapping")
+	}
+	for i := 0; i < len(value.Content); i += 2 {
+		key := value.Content[i].Value
+		node := value.Content[i+1]
+		switch key {
+		case "enabled":
+			if err := node.Decode(&c.Enabled); err != nil {
+				return err
+			}
+		case "endpoint":
+			if err := node.Decode(&c.Endpoint); err != nil {
+				return err
+			}
+		case "token_env":
+			if err := node.Decode(&c.TokenEnv); err != nil {
+				return err
+			}
+		case "timeout":
+			if err := node.Decode(&c.Timeout); err != nil {
+				return err
+			}
+		case "failure_policy":
+			if err := node.Decode(&c.FailurePolicy); err != nil {
+				return err
+			}
+		case "pipeline_id_template":
+			if err := node.Decode(&c.PipelineIDTemplate); err != nil {
+				return err
+			}
+		case "bundle_id_template":
+			if err := node.Decode(&c.BundleIDTemplate); err != nil {
+				return err
+			}
+		case "idempotency_key_template":
+			if err := node.Decode(&c.IdempotencyKeyTemplate); err != nil {
+				return err
+			}
+		case "batch":
+			if err := node.Decode(&c.Batch); err != nil {
+				return err
+			}
+		default:
+			return fmt.Errorf("unknown notify distributor field %q", key)
+		}
+	}
+	return nil
+}
+
+func (c *DistributorBatchNotifyConfig) UnmarshalYAML(value *yaml.Node) error {
+	if value.Kind != yaml.MappingNode {
+		return fmt.Errorf("notify distributor batch entry must be a mapping")
+	}
+	for i := 0; i < len(value.Content); i += 2 {
+		key := value.Content[i].Value
+		node := value.Content[i+1]
+		switch key {
+		case "enabled":
+			if err := node.Decode(&c.Enabled); err != nil {
+				return err
+			}
+		case "pipeline_id_template":
+			if err := node.Decode(&c.PipelineIDTemplate); err != nil {
+				return err
+			}
+		case "bundle_id_template":
+			if err := node.Decode(&c.BundleIDTemplate); err != nil {
+				return err
+			}
+		case "idempotency_key_template":
+			if err := node.Decode(&c.IdempotencyKeyTemplate); err != nil {
+				return err
+			}
+		default:
+			return fmt.Errorf("unknown notify distributor batch field %q", key)
+		}
+	}
+	return nil
+}
+
+func (c *ReportDistributorConfig) UnmarshalYAML(value *yaml.Node) error {
+	if value.Kind != yaml.MappingNode {
+		return fmt.Errorf("report distributor entry must be a mapping")
+	}
+	for i := 0; i < len(value.Content); i += 2 {
+		key := value.Content[i].Value
+		node := value.Content[i+1]
+		switch key {
+		case "path_templates":
+			if err := node.Decode(&c.PathTemplates); err != nil {
+				return err
+			}
+			c.pathTemplatesSet = true
+		default:
+			return fmt.Errorf("unknown report distributor field %q", key)
+		}
+	}
+	return nil
+}
+
+func (c ReportDistributorConfig) PathTemplatesSet() bool {
+	return c.pathTemplatesSet
+}
+
 func (m *ModuleConfigItem) UnmarshalYAML(value *yaml.Node) error {
 	switch value.Kind {
 	case yaml.ScalarNode:

internal/config/defaults.go

@@ -31,8 +31,11 @@ func Defaults() Config {
 				PipelineIDTemplate:     "",
 				BundleIDTemplate:       "weatherreporter.{location_id}.{report_id}",
 				IdempotencyKeyTemplate: "{bundle_id}.{run_id}",
-				ReportPathTemplates: []string{
-					"{valid_start_date}/{artifact_group}/{valid_start_date}-{artifact_group}-{run_id}.md",
+				Batch: DistributorBatchNotifyConfig{
+					Enabled:                true,
+					PipelineIDTemplate:     "weatherreporter",
+					BundleIDTemplate:       "weatherreporter.{location_id}.{batch}",
+					IdempotencyKeyTemplate: "{bundle_id}.{batch_run_id}",
 				},
 			},
 		},

internal/config/notify_templates.go

@@ -18,6 +18,15 @@ type DistributorTemplateValues struct {
 	ValidEndTime    string
 	ValidStartStamp string
 	ValidEndStamp   string
+	StormID         string
+	BundleID        string
+}
+
+type DistributorBatchTemplateValues struct {
+	LocationID       string
+	Batch            string
+	BatchRunID       string
+	BatchStartedDate string
 	BundleID         string
 }
 
@@ -33,6 +42,7 @@ var distributorTemplateVariables = map[string]struct{}{
 	"valid_end_time":    {},
 	"valid_start_stamp": {},
 	"valid_end_stamp":   {},
+	"storm_id":          {},
 }
 
 var distributorIdempotencyTemplateVariables = map[string]struct{}{
@@ -47,11 +57,29 @@ var distributorIdempotencyTemplateVariables = map[string]struct{}{
 	"valid_end_time":    {},
 	"valid_start_stamp": {},
 	"valid_end_stamp":   {},
+	"storm_id":          {},
 	"bundle_id":         {},
 }
 
 var distributorPipelineTemplateVariables = distributorIdempotencyTemplateVariables
 
+var distributorBatchTemplateVariables = map[string]struct{}{
+	"location_id":        {},
+	"batch":              {},
+	"batch_run_id":       {},
+	"batch_started_date": {},
+}
+
+var distributorBatchIdempotencyTemplateVariables = map[string]struct{}{
+	"location_id":        {},
+	"batch":              {},
+	"batch_run_id":       {},
+	"batch_started_date": {},
+	"bundle_id":          {},
+}
+
+var distributorBatchPipelineTemplateVariables = distributorBatchTemplateVariables
+
 func RenderDistributorBundleID(template string, values DistributorTemplateValues) (string, error) {
 	return renderDistributorTemplate("notify.distributor.bundle_id_template", template, values, distributorTemplateVariables)
 }
@@ -71,23 +99,56 @@ func RenderDistributorIdempotencyKey(template string, values DistributorTemplate
 	return renderDistributorTemplate("notify.distributor.idempotency_key_template", template, values, distributorIdempotencyTemplateVariables)
 }
 
-func RenderDistributorReportPaths(templates []string, values DistributorTemplateValues) ([]string, error) {
+func RenderDistributorBatchBundleID(template string, values DistributorBatchTemplateValues) (string, error) {
+	rendered, err := renderDistributorBatchTemplate("notify.distributor.batch.bundle_id_template", template, values, distributorBatchTemplateVariables)
+	if err != nil {
+		return "", err
+	}
+	if strings.TrimSpace(rendered) == "" {
+		return "", fmt.Errorf("notify.distributor.batch.bundle_id_template renders an empty bundle id")
+	}
+	return rendered, nil
+}
+
+func RenderDistributorBatchPipelineID(template string, values DistributorBatchTemplateValues) (string, error) {
+	rendered, err := renderDistributorBatchTemplate("notify.distributor.batch.pipeline_id_template", template, values, distributorBatchPipelineTemplateVariables)
+	if err != nil {
+		return "", err
+	}
+	if strings.TrimSpace(rendered) == "" {
+		return "", fmt.Errorf("notify.distributor.batch.pipeline_id_template renders an empty pipeline id")
+	}
+	return rendered, nil
+}
+
+func RenderDistributorBatchIdempotencyKey(template string, values DistributorBatchTemplateValues) (string, error) {
+	rendered, err := renderDistributorBatchTemplate("notify.distributor.batch.idempotency_key_template", template, values, distributorBatchIdempotencyTemplateVariables)
+	if err != nil {
+		return "", err
+	}
+	if strings.TrimSpace(rendered) == "" {
+		return "", fmt.Errorf("notify.distributor.batch.idempotency_key_template renders an empty idempotency key")
+	}
+	return rendered, nil
+}
+
+func RenderDistributorReportPaths(name string, templates []string, values DistributorTemplateValues) ([]string, error) {
 	if len(templates) == 0 {
-		return nil, fmt.Errorf("notify.distributor.report_path_templates must contain at least one entry")
+		return nil, fmt.Errorf("%s must contain at least one entry", name)
 	}
 	paths := make([]string, 0, len(templates))
 	seen := make(map[string]struct{}, len(templates))
 	for i, template := range templates {
-		name := fmt.Sprintf("notify.distributor.report_path_templates[%d]", i)
-		rendered, err := renderDistributorTemplate(name, template, values, distributorTemplateVariables)
+		itemName := fmt.Sprintf("%s[%d]", name, i)
+		rendered, err := renderDistributorTemplate(itemName, template, values, distributorTemplateVariables)
 		if err != nil {
 			return nil, err
 		}
-		if err := ValidateDistributorReportPath(name, rendered); err != nil {
+		if err := ValidateDistributorReportPath(itemName, rendered); err != nil {
 			return nil, err
 		}
 		if _, ok := seen[rendered]; ok {
-			return nil, fmt.Errorf("notify.distributor.report_path_templates renders duplicate path %q", rendered)
+			return nil, fmt.Errorf("%s renders duplicate path %q", name, rendered)
 		}
 		seen[rendered] = struct{}{}
 		paths = append(paths, rendered)
@@ -100,6 +161,11 @@ func validateDistributorTemplate(name, template string, allowed map[string]struc
 	return err
 }
 
+func validateDistributorBatchTemplate(name, template string, allowed map[string]struct{}) error {
+	_, err := renderDistributorBatchTemplate(name, template, DistributorBatchTemplateValues{}, allowed)
+	return err
+}
+
 func renderDistributorTemplate(name, template string, values DistributorTemplateValues, allowed map[string]struct{}) (string, error) {
 	var rendered strings.Builder
 	for i := 0; i < len(template); {
@@ -128,6 +194,34 @@ func renderDistributorTemplate(name, template string, values DistributorTemplate
 	return rendered.String(), nil
 }
 
+func renderDistributorBatchTemplate(name, template string, values DistributorBatchTemplateValues, allowed map[string]struct{}) (string, error) {
+	var rendered strings.Builder
+	for i := 0; i < len(template); {
+		switch template[i] {
+		case '{':
+			end := strings.IndexByte(template[i+1:], '}')
+			if end < 0 {
+				return "", fmt.Errorf("%s contains an unclosed template variable", name)
+			}
+			variable := template[i+1 : i+1+end]
+			if variable == "" {
+				return "", fmt.Errorf("%s contains an empty template variable", name)
+			}
+			if _, ok := allowed[variable]; !ok {
+				return "", fmt.Errorf("%s contains unknown template variable %q", name, variable)
+			}
+			rendered.WriteString(distributorBatchTemplateValue(variable, values))
+			i += end + 2
+		case '}':
+			return "", fmt.Errorf("%s contains an unopened template variable", name)
+		default:
+			rendered.WriteByte(template[i])
+			i++
+		}
+	}
+	return rendered.String(), nil
+}
+
 func distributorTemplateValue(variable string, values DistributorTemplateValues) string {
 	switch variable {
 	case "location_id":
@@ -152,6 +246,25 @@ func distributorTemplateValue(variable string, values DistributorTemplateValues)
 		return values.ValidStartStamp
 	case "valid_end_stamp":
 		return values.ValidEndStamp
+	case "storm_id":
+		return values.StormID
+	case "bundle_id":
+		return values.BundleID
+	default:
+		return ""
+	}
+}
+
+func distributorBatchTemplateValue(variable string, values DistributorBatchTemplateValues) string {
+	switch variable {
+	case "location_id":
+		return values.LocationID
+	case "batch":
+		return values.Batch
+	case "batch_run_id":
+		return values.BatchRunID
+	case "batch_started_date":
+		return values.BatchStartedDate
 	case "bundle_id":
 		return values.BundleID
 	default:
@@ -178,7 +291,7 @@ func ValidateDistributorReportPath(name, path string) error {
 		if segment == "." || segment == ".." {
 			return fmt.Errorf("%s must not render . or .. path segments", name)
 		}
-		if segment == "manifest.json" || segment == ".distributor.json" {
+		if segment == "manifest.json" || segment == distributorSidecarBasename() {
 			return fmt.Errorf("%s must not render reserved path segment %q", name, segment)
 		}
 	}
@@ -186,6 +299,10 @@ func ValidateDistributorReportPath(name, path string) error {
 	return nil
 }
 
+func distributorSidecarBasename() string {
+	return "." + "distributor.json"
+}
+
 func isDistributorAbsolutePath(path string) bool {
 	if filepath.IsAbs(path) || strings.HasPrefix(path, "/") {
 		return true

internal/config/reports.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"fmt"
 	"reflect"
-	"strings"
 
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
@@ -12,65 +11,163 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func (cfg Config) ReportModuleOverrides() map[report.ID][]module.ConfigItem {
-	overrides := map[report.ID][]module.ConfigItem{}
-	for key, reportCfg := range cfg.Reports {
-		if !reportCfg.deterministicModulesSet {
-			continue
-		}
-		id, err := reportIDForConfigKey(key)
-		if err != nil {
-			continue
-		}
-		items := make([]module.ConfigItem, 0, len(reportCfg.DeterministicModules))
-		for _, item := range reportCfg.DeterministicModules {
-			items = append(items, module.ConfigItem{ID: item.ID, Options: item.Options})
-		}
-		overrides[id] = items
-	}
-	return overrides
+func (cfg Config) ReportModuleOverrides() (map[report.ID][]module.ConfigItem, error) {
+	return traverseReportModules(&cfg, reportModuleTraversalOptions{
+		normalizeOptions: true,
+	})
+}
+
+func (cfg Config) ReportDistributorPathOverrides() (map[report.ID][]string, error) {
+	return traverseReportDistributorPathOverrides(cfg)
 }
 
 func normalizeReportModules(cfg *Config) error {
 	if cfg.Reports == nil {
 		cfg.Reports = map[string]ReportConfig{}
 	}
+	_, err := traverseReportModules(cfg, reportModuleTraversalOptions{
+		normalizeOptions: true,
+		updateConfig:     true,
+	})
+	return err
+}
+
+func validateReportModules(cfg Config) error {
+	_, err := traverseReportModules(&cfg, reportModuleTraversalOptions{
+		normalizeOptions: true,
+	})
+	return err
+}
+
+func validateReportDistributorPathOverrides(cfg Config) error {
+	_, err := traverseReportDistributorPathOverrides(cfg)
+	return err
+}
+
+type reportModuleTraversalOptions struct {
+	normalizeOptions bool
+	updateConfig     bool
+}
+
+func traverseReportModules(cfg *Config, opts reportModuleTraversalOptions) (map[report.ID][]module.ConfigItem, error) {
+	overrides := map[report.ID][]module.ConfigItem{}
+	if cfg.Reports == nil {
+		return overrides, nil
+	}
 	moduleRegistry, err := briefing.DefaultModuleRegistry()
 	if err != nil {
-		return fmt.Errorf("initialize module registry: %w", err)
+		return nil, fmt.Errorf("initialize module registry: %w", err)
 	}
 	reportRegistry := report.DefaultRegistry()
 	seenReports := map[report.ID]string{}
 	for key, reportCfg := range cfg.Reports {
-		reportID, err := reportIDForConfigKey(key)
+		reportID, err := report.IDForConfigKey(key)
 		if err != nil {
-			return err
+			return nil, fmt.Errorf("reports.%s: %w", key, err)
 		}
 		if previous, ok := seenReports[reportID]; ok {
-			return fmt.Errorf("reports.%s duplicates report override %q", key, previous)
+			return nil, fmt.Errorf("reports.%s duplicates report override %q", key, previous)
 		}
 		seenReports[reportID] = key
 		if _, err := reportRegistry.Lookup(reportID); err != nil {
-			return fmt.Errorf("reports.%s: %w", key, err)
+			return nil, fmt.Errorf("reports.%s: %w", key, err)
 		}
 		if !reportCfg.deterministicModulesSet {
 			continue
 		}
-		items := make([]module.ConfigItem, 0, len(reportCfg.DeterministicModules))
-		for i, rawItem := range reportCfg.DeterministicModules {
-			options, err := normalizeModuleOptions(moduleRegistry, rawItem.ID, rawItem.Options)
+		items, normalized, err := moduleItemsFromConfig(moduleRegistry, key, reportCfg.DeterministicModules, opts.normalizeOptions)
 		if err != nil {
-				return fmt.Errorf("reports.%s.deterministic_modules[%d]: %w", key, i, err)
-			}
-			reportCfg.DeterministicModules[i].Options = options
-			items = append(items, module.ConfigItem{ID: rawItem.ID, Options: options})
+			return nil, err
 		}
 		if err := moduleRegistry.ValidateComposition(reportID, items); err != nil {
-			return fmt.Errorf("reports.%s.deterministic_modules: %w", key, err)
+			return nil, fmt.Errorf("reports.%s.deterministic_modules: %w", key, err)
 		}
+		overrides[reportID] = items
+		if opts.updateConfig {
+			reportCfg.DeterministicModules = normalized
 			cfg.Reports[key] = reportCfg
 		}
-	return nil
+	}
+	return overrides, nil
+}
+
+func traverseReportDistributorPathOverrides(cfg Config) (map[report.ID][]string, error) {
+	overrides := map[report.ID][]string{}
+	if cfg.Reports == nil {
+		return overrides, nil
+	}
+	reportRegistry := report.DefaultRegistry()
+	seenReports := map[report.ID]string{}
+	for key, reportCfg := range cfg.Reports {
+		reportID, err := report.IDForConfigKey(key)
+		if err != nil {
+			return nil, fmt.Errorf("reports.%s: %w", key, err)
+		}
+		if previous, ok := seenReports[reportID]; ok {
+			return nil, fmt.Errorf("reports.%s duplicates report override %q", key, previous)
+		}
+		seenReports[reportID] = key
+		if _, err := reportRegistry.Lookup(reportID); err != nil {
+			return nil, fmt.Errorf("reports.%s: %w", key, err)
+		}
+		if !reportCfg.Distributor.pathTemplatesSet {
+			continue
+		}
+		if err := validateReportDistributorPathTemplates(key, reportID, reportCfg.Distributor.PathTemplates); err != nil {
+			return nil, err
+		}
+		overrides[reportID] = append([]string(nil), reportCfg.Distributor.PathTemplates...)
+	}
+	return overrides, nil
+}
+
+func validateReportDistributorPathTemplates(reportKey string, reportID report.ID, templates []string) error {
+	name := fmt.Sprintf("reports.%s.distributor.path_templates", reportKey)
+	_, err := RenderDistributorReportPaths(name, templates, sampleDistributorTemplateValuesForReport(reportID))
+	return err
+}
+
+func sampleDistributorTemplateValues() DistributorTemplateValues {
+	return sampleDistributorTemplateValuesForReport(report.Storm)
+}
+
+func sampleDistributorTemplateValuesForReport(reportID report.ID) DistributorTemplateValues {
+	stormID := ""
+	if reportID == report.Storm {
+		stormID = "2026-05-29T0000-2026-05-30T0000"
+	}
+	return DistributorTemplateValues{
+		LocationID:      "location",
+		ReportID:        "report",
+		RunID:           "run",
+		ArtifactGroup:   "artifact",
+		BatchOutputName: "report.md",
+		ValidStartDate:  "2026-05-29",
+		ValidEndDate:    "2026-05-30",
+		ValidStartTime:  "0000",
+		ValidEndTime:    "0000",
+		ValidStartStamp: "2026-05-29T0000",
+		ValidEndStamp:   "2026-05-30T0000",
+		StormID:         stormID,
+	}
+}
+
+func moduleItemsFromConfig(registry briefing.ModuleRegistry, reportKey string, items []ModuleConfigItem, normalizeOptions bool) ([]module.ConfigItem, []ModuleConfigItem, error) {
+	out := make([]module.ConfigItem, 0, len(items))
+	normalizedItems := append([]ModuleConfigItem(nil), items...)
+	for i, item := range items {
+		options := item.Options
+		if normalizeOptions {
+			var err error
+			options, err = normalizeModuleOptions(registry, item.ID, item.Options)
+			if err != nil {
+				return nil, nil, fmt.Errorf("reports.%s.deterministic_modules[%d]: %w", reportKey, i, err)
+			}
+			normalizedItems[i].Options = options
+		}
+		out = append(out, module.ConfigItem{ID: item.ID, Options: options})
+	}
+	return out, normalizedItems, nil
 }
 
 func normalizeModuleOptions(registry briefing.ModuleRegistry, id module.ID, raw any) (any, error) {
@@ -84,6 +181,9 @@ func normalizeModuleOptions(registry briefing.ModuleRegistry, id module.ID, raw
 	if definition.DefaultOptions == nil {
 		return nil, fmt.Errorf("module %q does not accept options", id)
 	}
+	if err := definition.ValidateOptions(raw); err == nil {
+		return raw, nil
+	}
 	optionType := reflect.TypeOf(definition.DefaultOptions)
 	normalized, err := decodeKnownOptions(raw, optionType)
 	if err != nil {
@@ -105,23 +205,3 @@ func decodeKnownOptions(raw any, optionType reflect.Type) (any, error) {
 	}
 	return target.Elem().Interface(), nil
 }
-
-func reportIDForConfigKey(key string) (report.ID, error) {
-	normalized := strings.ReplaceAll(strings.TrimSpace(strings.ToLower(key)), "-", "_")
-	switch normalized {
-	case "daily", "daily_today":
-		return report.DailyToday, nil
-	case "tomorrow":
-		return report.Tomorrow, nil
-	case "hourly":
-		return report.Hourly, nil
-	case "three_day", "three_day_outlook":
-		return report.ThreeDay, nil
-	case "weekend", "weekend_outlook":
-		return report.Weekend, nil
-	case "storm", "storm_report":
-		return report.Storm, nil
-	default:
-		return "", fmt.Errorf("reports.%s is not a known report", key)
-	}
-}

internal/config/validate.go

@@ -9,7 +9,10 @@ import (
 )
 
 func Validate(cfg Config) error {
-	if err := normalizeReportModules(&cfg); err != nil {
+	if err := validateReportModules(cfg); err != nil {
+		return err
+	}
+	if err := validateReportDistributorPathOverrides(cfg); err != nil {
 		return err
 	}
 	if cfg.WeatherAPI.BaseURL != "" {
@@ -121,22 +124,7 @@ func validateDistributorNotify(cfg DistributorNotifyConfig) error {
 	if err := validateDistributorTemplate("notify.distributor.idempotency_key_template", cfg.IdempotencyKeyTemplate, distributorIdempotencyTemplateVariables); err != nil {
 		return err
 	}
-	if len(cfg.ReportPathTemplates) == 0 {
-		return fmt.Errorf("notify.distributor.report_path_templates must contain at least one entry when enabled")
-	}
-	values := DistributorTemplateValues{
-		LocationID:      "location",
-		ReportID:        "report",
-		RunID:           "run",
-		ArtifactGroup:   "artifact",
-		BatchOutputName: "report.md",
-		ValidStartDate:  "2026-05-29",
-		ValidEndDate:    "2026-05-30",
-		ValidStartTime:  "0000",
-		ValidEndTime:    "0000",
-		ValidStartStamp: "2026-05-29T0000",
-		ValidEndStamp:   "2026-05-30T0000",
-	}
+	values := sampleDistributorTemplateValues()
 	bundleID, err := RenderDistributorBundleID(cfg.BundleIDTemplate, values)
 	if err != nil {
 		return err
@@ -145,13 +133,56 @@ func validateDistributorNotify(cfg DistributorNotifyConfig) error {
 	if _, err := RenderDistributorPipelineID(cfg.PipelineIDTemplate, values); err != nil {
 		return err
 	}
-	if _, err := RenderDistributorReportPaths(cfg.ReportPathTemplates, values); err != nil {
+	if err := validateDistributorBatchNotify(cfg.Batch); err != nil {
 		return err
 	}
 
 	return nil
 }
 
+func validateDistributorBatchNotify(cfg DistributorBatchNotifyConfig) error {
+	if !cfg.Enabled {
+		return nil
+	}
+	if cfg.PipelineIDTemplate == "" {
+		return fmt.Errorf("notify.distributor.batch.pipeline_id_template is required when enabled")
+	}
+	if err := validateDistributorBatchTemplate("notify.distributor.batch.pipeline_id_template", cfg.PipelineIDTemplate, distributorBatchPipelineTemplateVariables); err != nil {
+		return err
+	}
+	if cfg.BundleIDTemplate == "" {
+		return fmt.Errorf("notify.distributor.batch.bundle_id_template is required when enabled")
+	}
+	if err := validateDistributorBatchTemplate("notify.distributor.batch.bundle_id_template", cfg.BundleIDTemplate, distributorBatchTemplateVariables); err != nil {
+		return err
+	}
+	if cfg.IdempotencyKeyTemplate == "" {
+		return fmt.Errorf("notify.distributor.batch.idempotency_key_template is required when enabled")
+	}
+	if err := validateDistributorBatchTemplate("notify.distributor.batch.idempotency_key_template", cfg.IdempotencyKeyTemplate, distributorBatchIdempotencyTemplateVariables); err != nil {
+		return err
+	}
+
+	values := DistributorBatchTemplateValues{
+		LocationID:       "location",
+		Batch:            "morning",
+		BatchRunID:       "20260529T100000.000000000Z_morning",
+		BatchStartedDate: "2026-05-29",
+	}
+	bundleID, err := RenderDistributorBatchBundleID(cfg.BundleIDTemplate, values)
+	if err != nil {
+		return err
+	}
+	values.BundleID = bundleID
+	if _, err := RenderDistributorBatchPipelineID(cfg.PipelineIDTemplate, values); err != nil {
+		return err
+	}
+	if _, err := RenderDistributorBatchIdempotencyKey(cfg.IdempotencyKeyTemplate, values); err != nil {
+		return err
+	}
+	return nil
+}
+
 func validatePolicy(name string, policy MissingSourcePolicy) error {
 	switch policy {
 	case MissingSourceError, MissingSourceWarn, MissingSourceNone:

internal/facts/facts.go

@@ -115,7 +115,7 @@ func BuildDerived(req BuildDerivedRequest) (DerivedFacts, error) {
 
 	switch req.Resolved.Definition.ID {
 	case report.Hourly:
-	case report.DailyToday, report.Tomorrow:
+	case report.Daily, report.Today, report.Tomorrow:
 		summary, err := forecast.BuildDailySummary(bundle, period.Start, location, req.Dayparts)
 		if err != nil {
 			return DerivedFacts{}, err

internal/facts/facts_test.go

@@ -56,7 +56,7 @@ func TestBuildCollectedCopiesBundleFactsAndKeepsSourcesSeparate(t *testing.T) {
 
 func TestBuildDerivedDailySlicesDaypartsAndAlerts(t *testing.T) {
 	location := testLocation()
-	resolved := resolveForTest(t, report.DailyToday, mustParse("2026-05-29T08:00:00-05:00"), location)
+	resolved := resolveForTest(t, report.Daily, mustParse("2026-05-29T08:00:00-05:00"), location)
 	derived, err := BuildDerived(BuildDerivedRequest{
 		Resolved:  resolved,
 		Timezone:  location.String(),
@@ -252,8 +252,8 @@ func TestBuildDerivedSelectsSPCConvectiveOutlooksByValidPeriod(t *testing.T) {
 		wantDiscussion []string
 	}{
 		{
-			name:           "daily today",
-			resolved:       resolveForTest(t, report.DailyToday, now, location),
+			name:           "daily",
+			resolved:       resolveForTest(t, report.Daily, now, location),
 			wantOutlookIDs: []string{"fri-high", "fri-storm", "fri-low", "fri-missing-rank", "fri-probabilistic"},
 			wantDiscussion: []string{"day1 early", "day1 late"},
 		},
@@ -322,7 +322,7 @@ func TestBuildDerivedUnsupportedReportReturnsActionableError(t *testing.T) {
 
 func TestBuildDerivedSPCConvectiveOutlooksDistinguishesMissingAndCheckedEmpty(t *testing.T) {
 	location := testLocation()
-	resolved := resolveForTest(t, report.DailyToday, mustParse("2026-05-29T08:00:00-05:00"), location)
+	resolved := resolveForTest(t, report.Daily, mustParse("2026-05-29T08:00:00-05:00"), location)
 	bundle := testBundle(location)
 	bundle.SPCConvectiveOutlooks = nil
 
@@ -465,7 +465,11 @@ func testDayparts() []forecast.DaypartDefinition {
 
 func resolveForTest(t *testing.T, id report.ID, now time.Time, location *time.Location) report.Resolved {
 	t.Helper()
-	resolved, err := report.Resolve(id, report.ResolveRequest{Now: now, Location: location})
+	req := report.ResolveRequest{Now: now, Location: location}
+	if id == report.Daily {
+		req.Date = now
+	}
+	resolved, err := report.Resolve(id, req)
 	if err != nil {
 		t.Fatalf("resolve %s: %v", id, err)
 	}

internal/forecast/derive.go

@@ -65,6 +65,7 @@ type AlertOverlap struct {
 	Period      timeutil.Period `json:"period"`
 	Overlap     timeutil.Period `json:"overlap"`
 	Description string          `json:"description,omitempty"`
+	Instruction string          `json:"instruction,omitempty"`
 }
 
 type PrecipTiming struct {
@@ -81,6 +82,7 @@ type PrecipitationWindow struct {
 	End                         *time.Time `json:"end,omitempty"`
 	MaxPrecipitationProbability TimedValue `json:"maxPrecipitationProbability"`
 	ProbabilityThreshold        float64    `json:"probabilityThreshold"`
+	TextDescriptions            []string   `json:"textDescriptions,omitempty"`
 }
 
 func BuildPrecipTiming(periods []weatherdata.ForecastPeriod) PrecipTiming {
@@ -114,6 +116,7 @@ func buildPrecipTimingWithThreshold(periods []weatherdata.ForecastPeriod, thresh
 			},
 			ProbabilityThreshold: threshold,
 		}
+		appendActiveTextDescription(active, forecastPeriod.TextDescription)
 		activeLastEnd = forecastPeriod.EndTime
 		if timing.FirstPrecipitation == nil {
 			timing.FirstPrecipitation = &TimedValue{
@@ -135,6 +138,8 @@ func buildPrecipTimingWithThreshold(periods []weatherdata.ForecastPeriod, thresh
 				if forecastPeriod.StartTime.After(activeLastEnd) {
 					closeActive()
 					startActive(forecastPeriod, probability)
+				} else {
+					appendActiveTextDescription(active, forecastPeriod.TextDescription)
 				}
 				if probability > active.MaxPrecipitationProbability.Value {
 					active.MaxPrecipitationProbability = TimedValue{
@@ -166,6 +171,17 @@ func buildPrecipTimingWithThreshold(periods []weatherdata.ForecastPeriod, thresh
 	return timing
 }
 
+func appendActiveTextDescription(window *PrecipitationWindow, text string) {
+	if window == nil {
+		return
+	}
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return
+	}
+	window.TextDescriptions = append(window.TextDescriptions, text)
+}
+
 func BuildDailySummary(bundle *weatherdata.Bundle, date time.Time, location *time.Location, dayparts []DaypartDefinition) (*DailySummary, error) {
 	if bundle == nil {
 		return nil, fmt.Errorf("forecast bundle is required")
@@ -448,6 +464,7 @@ func AlertOverlaps(alertRun *weatherdata.AlertRun, period timeutil.Period) []Ale
 			Period:      alert.Period,
 			Overlap:     intersect(alert.Period, period),
 			Description: alert.Description,
+			Instruction: alert.Instruction,
 		})
 	}
 	sort.SliceStable(overlaps, func(i int, j int) bool {
@@ -461,6 +478,7 @@ type parsedAlert struct {
 	Headline    string
 	Severity    string
 	Description string
+	Instruction string
 	Period      timeutil.Period
 }
 
@@ -473,14 +491,19 @@ func parseAlert(raw json.RawMessage) (parsedAlert, bool) {
 		Event:       stringField(fields, "event"),
 		Headline:    firstStringField(fields, "headline", "title"),
 		Severity:    stringField(fields, "severity"),
-		Description: firstStringField(fields, "description", "instruction"),
+		Description: stringField(fields, "description"),
+		Instruction: collapseWhitespace(stringField(fields, "instruction")),
 	}
-	start, startOK := firstTimeField(fields, "effective", "onset", "startsAt", "startTime", "sent")
-	end, endOK := firstTimeField(fields, "expires", "ends", "endsAt", "endTime")
+	start, startOK := firstTimeField(fields, "onset", "startsAt", "startTime", "effective", "sent")
+	end, endOK := firstTimeField(fields, "ends", "endsAt", "endTime", "expires")
 	if !startOK || !endOK {
 		return parsedAlert{}, false
 	}
-	alert.Period = timeutil.Period{Start: start, End: end}
+	period := timeutil.Period{Start: start, End: end}
+	if !period.IsValid() {
+		return parsedAlert{}, false
+	}
+	alert.Period = period
 	return alert, true
 }
 
@@ -519,6 +542,10 @@ func firstTimeField(fields map[string]json.RawMessage, names ...string) (time.Ti
 	return time.Time{}, false
 }
 
+func collapseWhitespace(value string) string {
+	return strings.Join(strings.Fields(value), " ")
+}
+
 func intersect(left timeutil.Period, right timeutil.Period) timeutil.Period {
 	start := left.Start
 	if right.Start.After(start) {

internal/forecast/derive_test.go

@@ -210,6 +210,115 @@ func TestAlertOverlap(t *testing.T) {
 	}
 }
 
+func TestAlertOverlapUsesOnsetAndEnds(t *testing.T) {
+	raw := json.RawMessage(`{"event":"Wind Advisory","headline":"Wind Advisory issued June 16 at 12:39PM CDT until June 17 at 8:00PM CDT by NWS St Louis MO","severity":"Moderate","description":"Southwest winds 20 to 30 mph with gusts up to 45 mph expected.","instruction":"Secure outdoor objects.\n\nUse  extra\tcaution.","effective":"2026-06-16T17:39:00Z","onset":"2026-06-17T18:00:00Z","ends":"2026-06-18T01:00:00Z","expires":"2026-06-17T08:45:00Z"}`)
+	alertRun := &weatherdata.AlertRun{Alerts: []json.RawMessage{raw}}
+	period := timeutil.Period{
+		Start: mustParse("2026-06-17T12:00:00-05:00"),
+		End:   mustParse("2026-06-17T21:00:00-05:00"),
+	}
+
+	overlaps := AlertOverlaps(alertRun, period)
+	if len(overlaps) != 1 {
+		t.Fatalf("overlaps length = %d, want 1", len(overlaps))
+	}
+	if overlaps[0].Period.Start.Format(time.RFC3339) != "2026-06-17T18:00:00Z" {
+		t.Fatalf("alert period start = %s, want onset", overlaps[0].Period.Start.Format(time.RFC3339))
+	}
+	if overlaps[0].Period.End.Format(time.RFC3339) != "2026-06-18T01:00:00Z" {
+		t.Fatalf("alert period end = %s, want ends", overlaps[0].Period.End.Format(time.RFC3339))
+	}
+	if overlaps[0].Overlap.Start.Format(time.RFC3339) != "2026-06-17T18:00:00Z" {
+		t.Fatalf("overlap start = %s, want onset", overlaps[0].Overlap.Start.Format(time.RFC3339))
+	}
+	if overlaps[0].Overlap.End.Format(time.RFC3339) != "2026-06-18T01:00:00Z" {
+		t.Fatalf("overlap end = %s, want alert ends", overlaps[0].Overlap.End.Format(time.RFC3339))
+	}
+	if overlaps[0].Description != "Southwest winds 20 to 30 mph with gusts up to 45 mph expected." {
+		t.Fatalf("Description = %q, want preserved description", overlaps[0].Description)
+	}
+	if overlaps[0].Instruction != "Secure outdoor objects. Use extra caution." {
+		t.Fatalf("Instruction = %q, want preserved instruction", overlaps[0].Instruction)
+	}
+}
+
+func TestCollapseWhitespace(t *testing.T) {
+	tests := []struct {
+		name  string
+		value string
+		want  string
+	}{
+		{name: "newlines", value: "Secure outdoor objects.\nUse extra caution.", want: "Secure outdoor objects. Use extra caution."},
+		{name: "crlf", value: "Secure outdoor objects.\r\nUse extra caution.", want: "Secure outdoor objects. Use extra caution."},
+		{name: "tabs and repeated spaces", value: "Secure\toutdoor   objects.", want: "Secure outdoor objects."},
+		{name: "leading trailing", value: "  Secure outdoor objects.  ", want: "Secure outdoor objects."},
+		{name: "empty", value: "", want: ""},
+		{name: "all whitespace", value: " \n\t\r\n ", want: ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := collapseWhitespace(tt.value); got != tt.want {
+				t.Fatalf("collapseWhitespace(%q) = %q, want %q", tt.value, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestAlertOverlapUsesOnsetAndEndsForLocalDateRelevance(t *testing.T) {
+	location, err := time.LoadLocation("America/Chicago")
+	if err != nil {
+		t.Fatalf("load location: %v", err)
+	}
+	raw := json.RawMessage(`{"event":"Wind Advisory","headline":"Wind Advisory issued June 16 at 12:39PM CDT until June 17 at 8:00PM CDT by NWS St Louis MO","severity":"Moderate","effective":"2026-06-16T17:39:00Z","onset":"2026-06-17T18:00:00Z","ends":"2026-06-18T01:00:00Z","expires":"2026-06-17T08:45:00Z"}`)
+	alertRun := &weatherdata.AlertRun{Alerts: []json.RawMessage{raw}}
+	june16 := timeutil.CivilDay(time.Date(2026, 6, 16, 12, 0, 0, 0, location), location)
+	june17Afternoon := timeutil.Period{
+		Start: time.Date(2026, 6, 17, 12, 0, 0, 0, location),
+		End:   time.Date(2026, 6, 17, 21, 0, 0, 0, location),
+	}
+
+	if overlaps := AlertOverlaps(alertRun, june16); len(overlaps) != 0 {
+		t.Fatalf("June 16 overlaps length = %d, want none: %#v", len(overlaps), overlaps)
+	}
+	if overlaps := AlertOverlaps(alertRun, june17Afternoon); len(overlaps) != 1 {
+		t.Fatalf("June 17 afternoon overlaps length = %d, want 1: %#v", len(overlaps), overlaps)
+	}
+}
+
+func TestAlertOverlapSupportsOlderEffectiveExpiresPayload(t *testing.T) {
+	raw := json.RawMessage(`{"event":"Flood Watch","headline":"Flooding possible","severity":"Moderate","effective":"2026-05-29T07:00:00-05:00","expires":"2026-05-29T10:00:00-05:00"}`)
+	alertRun := &weatherdata.AlertRun{Alerts: []json.RawMessage{raw}}
+	period := timeutil.Period{
+		Start: mustParse("2026-05-29T06:00:00-05:00"),
+		End:   mustParse("2026-05-29T11:00:00-05:00"),
+	}
+
+	overlaps := AlertOverlaps(alertRun, period)
+	if len(overlaps) != 1 {
+		t.Fatalf("overlaps length = %d, want 1", len(overlaps))
+	}
+	if overlaps[0].Period.Start.Format(time.RFC3339) != "2026-05-29T07:00:00-05:00" {
+		t.Fatalf("alert period start = %s, want effective fallback", overlaps[0].Period.Start.Format(time.RFC3339))
+	}
+	if overlaps[0].Period.End.Format(time.RFC3339) != "2026-05-29T10:00:00-05:00" {
+		t.Fatalf("alert period end = %s, want expires fallback", overlaps[0].Period.End.Format(time.RFC3339))
+	}
+}
+
+func TestAlertOverlapSkipsInvalidSelectedPeriod(t *testing.T) {
+	raw := json.RawMessage(`{"event":"Wind Advisory","headline":"Invalid event period","severity":"Moderate","onset":"2026-06-17T18:00:00Z","ends":"2026-06-17T08:45:00Z"}`)
+	alertRun := &weatherdata.AlertRun{Alerts: []json.RawMessage{raw}}
+	period := timeutil.Period{
+		Start: mustParse("2026-06-17T00:00:00Z"),
+		End:   mustParse("2026-06-18T00:00:00Z"),
+	}
+
+	if overlaps := AlertOverlaps(alertRun, period); len(overlaps) != 0 {
+		t.Fatalf("overlaps length = %d, want invalid alert skipped: %#v", len(overlaps), overlaps)
+	}
+}
+
 func TestBuildPrecipTimingBuildsThresholdWindows(t *testing.T) {
 	location := time.FixedZone("Test", -5*60*60)
 	periods := []weatherdata.ForecastPeriod{
@@ -245,10 +354,16 @@ func TestBuildPrecipTimingBuildsThresholdWindows(t *testing.T) {
 	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)
 	}
+	if len(first.TextDescriptions) != 2 || first.TextDescriptions[0] != "Showers" || first.TextDescriptions[1] != "Rain likely" {
+		t.Fatalf("first window text descriptions = %#v, want contributing hourly descriptions", first.TextDescriptions)
+	}
 	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 len(second.TextDescriptions) != 1 || second.TextDescriptions[0] != "Thunderstorms" {
+		t.Fatalf("second window text descriptions = %#v, want thunderstorm description", second.TextDescriptions)
+	}
 	if !timing.ThunderMentioned {
 		t.Fatal("ThunderMentioned = false, want true")
 	}

internal/generatedtext/catalog.go

@@ -0,0 +1,195 @@
+package generatedtext
+
+import (
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/facts"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/reporttemplate"
+)
+
+const (
+	schemaIDHourly   = "hourly"
+	schemaIDDaily    = "daily"
+	schemaIDToday    = "today"
+	schemaIDTomorrow = "tomorrow"
+
+	templateIDHourly   = "hourly"
+	templateIDDaily    = "daily"
+	templateIDToday    = "today"
+	templateIDTomorrow = "tomorrow"
+)
+
+type validator func([]byte) (any, []byte, error)
+
+type renderContextBuilder func(report.ID, string, briefing.Metadata, module.Snapshot, facts.CollectedFacts, facts.DerivedFacts, any) (any, error)
+
+type catalogEntry struct {
+	schemaID             string
+	templateID           string
+	validate             validator
+	renderContextBuilder renderContextBuilder
+}
+
+type Handler struct {
+	reportID             report.ID
+	schemaID             string
+	templateID           string
+	validate             validator
+	renderContextBuilder renderContextBuilder
+}
+
+var catalog = []catalogEntry{
+	{
+		schemaID:             schemaIDHourly,
+		templateID:           templateIDHourly,
+		validate:             validateHourly,
+		renderContextBuilder: buildHourlyContext,
+	},
+	{
+		schemaID:             schemaIDDaily,
+		templateID:           templateIDDaily,
+		validate:             validateDaily,
+		renderContextBuilder: buildDailyContext,
+	},
+	{
+		schemaID:             schemaIDToday,
+		templateID:           templateIDToday,
+		validate:             validateToday,
+		renderContextBuilder: buildTodayContext,
+	},
+	{
+		schemaID:             schemaIDTomorrow,
+		templateID:           templateIDTomorrow,
+		validate:             validateTomorrow,
+		renderContextBuilder: buildTomorrowContext,
+	},
+}
+
+func LookupDefinition(definition report.Definition) (Handler, error) {
+	if definition.GenerationMode != report.GenerationModeGeneratedTextTemplate {
+		return Handler{}, fmt.Errorf("report %q uses generation mode %q, not %q", definition.ID, definition.GenerationMode, report.GenerationModeGeneratedTextTemplate)
+	}
+
+	var schemaKnown, templateKnown bool
+	for _, entry := range catalog {
+		if entry.schemaID == definition.GeneratedTextSchemaID {
+			schemaKnown = true
+		}
+		if entry.templateID == definition.TemplateID {
+			templateKnown = true
+		}
+		if entry.schemaID == definition.GeneratedTextSchemaID && entry.templateID == definition.TemplateID {
+			return Handler{
+				reportID:             definition.ID,
+				schemaID:             entry.schemaID,
+				templateID:           entry.templateID,
+				validate:             entry.validate,
+				renderContextBuilder: entry.renderContextBuilder,
+			}, nil
+		}
+	}
+	if !schemaKnown {
+		return Handler{}, fmt.Errorf("generated text schema %q is not supported for report %q", definition.GeneratedTextSchemaID, definition.ID)
+	}
+	if !templateKnown {
+		return Handler{}, fmt.Errorf("report template %q is not supported for report %q", definition.TemplateID, definition.ID)
+	}
+	return Handler{}, fmt.Errorf("generated text schema %q and report template %q are not supported together for report %q", definition.GeneratedTextSchemaID, definition.TemplateID, definition.ID)
+}
+
+func (h Handler) SchemaID() string {
+	return h.schemaID
+}
+
+func (h Handler) TemplateID() string {
+	return h.templateID
+}
+
+func (h Handler) Schema() ([]byte, error) {
+	data, err := reporttemplate.Schema(h.schemaID)
+	if err != nil {
+		return nil, fmt.Errorf("load generated text schema %q for report %q: %w", h.schemaID, h.reportID, err)
+	}
+	return data, nil
+}
+
+func (h Handler) Template() (string, error) {
+	source, err := reporttemplate.Template(h.templateID)
+	if err != nil {
+		return "", fmt.Errorf("load report template %q for report %q: %w", h.templateID, h.reportID, err)
+	}
+	return source, nil
+}
+
+func (h Handler) Validate(data []byte) (any, []byte, error) {
+	if h.validate == nil {
+		return nil, nil, fmt.Errorf("generated text validator is not registered for schema %q on report %q", h.schemaID, h.reportID)
+	}
+	return h.validate(data)
+}
+
+func (h Handler) BuildRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, collected facts.CollectedFacts, derived facts.DerivedFacts, generated any) (any, error) {
+	if h.renderContextBuilder == nil {
+		return nil, fmt.Errorf("render-context builder is not registered for template %q on report %q", h.templateID, h.reportID)
+	}
+	return h.renderContextBuilder(h.reportID, h.templateID, metadata, snapshot, collected, derived, generated)
+}
+
+func (h Handler) Render(data any) ([]byte, error) {
+	rendered, err := reporttemplate.Render(h.templateID, data)
+	if err != nil {
+		return nil, fmt.Errorf("render report template %q for report %q: %w", h.templateID, h.reportID, err)
+	}
+	return rendered, nil
+}
+
+func validateHourly(data []byte) (any, []byte, error) {
+	return ValidateHourly(data)
+}
+
+func validateDaily(data []byte) (any, []byte, error) {
+	return ValidateDaily(data)
+}
+
+func validateToday(data []byte) (any, []byte, error) {
+	return ValidateToday(data)
+}
+
+func validateTomorrow(data []byte) (any, []byte, error) {
+	return ValidateTomorrow(data)
+}
+
+func buildHourlyContext(reportID report.ID, templateID string, metadata briefing.Metadata, snapshot module.Snapshot, collected facts.CollectedFacts, derived facts.DerivedFacts, generated any) (any, error) {
+	hourly, ok := generated.(Hourly)
+	if !ok {
+		return nil, fmt.Errorf("report template %q requires hourly generated text for report %q", templateID, reportID)
+	}
+	return BuildHourlyRenderContext(metadata, snapshot, hourly, collected, derived)
+}
+
+func buildDailyContext(reportID report.ID, templateID string, metadata briefing.Metadata, snapshot module.Snapshot, collected facts.CollectedFacts, derived facts.DerivedFacts, generated any) (any, error) {
+	daily, ok := generated.(Daily)
+	if !ok {
+		return nil, fmt.Errorf("report template %q requires daily generated text for report %q", templateID, reportID)
+	}
+	return BuildDailyRenderContext(metadata, snapshot, daily, collected, derived)
+}
+
+func buildTodayContext(reportID report.ID, templateID string, metadata briefing.Metadata, snapshot module.Snapshot, collected facts.CollectedFacts, derived facts.DerivedFacts, generated any) (any, error) {
+	today, ok := generated.(Today)
+	if !ok {
+		return nil, fmt.Errorf("report template %q requires today generated text for report %q", templateID, reportID)
+	}
+	return BuildTodayRenderContext(metadata, snapshot, today, collected, derived)
+}
+
+func buildTomorrowContext(reportID report.ID, templateID string, metadata briefing.Metadata, snapshot module.Snapshot, collected facts.CollectedFacts, derived facts.DerivedFacts, generated any) (any, error) {
+	tomorrow, ok := generated.(Tomorrow)
+	if !ok {
+		return nil, fmt.Errorf("report template %q requires tomorrow generated text for report %q", templateID, reportID)
+	}
+	return BuildTomorrowRenderContext(metadata, snapshot, tomorrow, collected, derived)
+}

internal/generatedtext/catalog_test.go

@@ -0,0 +1,324 @@
+package generatedtext
+
+import (
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
+)
+
+func TestCatalogCompleteForGeneratedTextTemplateReports(t *testing.T) {
+	for _, definition := range report.DefaultRegistry().All() {
+		if definition.GenerationMode != report.GenerationModeGeneratedTextTemplate {
+			continue
+		}
+		t.Run(string(definition.ID), func(t *testing.T) {
+			handler, err := LookupDefinition(definition)
+			if err != nil {
+				t.Fatalf("LookupDefinition() error = %v", err)
+			}
+			if handler.SchemaID() != definition.GeneratedTextSchemaID {
+				t.Fatalf("SchemaID() = %q, want %q", handler.SchemaID(), definition.GeneratedTextSchemaID)
+			}
+			if handler.TemplateID() != definition.TemplateID {
+				t.Fatalf("TemplateID() = %q, want %q", handler.TemplateID(), definition.TemplateID)
+			}
+			if handler.validate == nil {
+				t.Fatal("validator is nil")
+			}
+			if handler.renderContextBuilder == nil {
+				t.Fatal("render-context builder is nil")
+			}
+			if schema, err := handler.Schema(); err != nil {
+				t.Fatalf("Schema() error = %v", err)
+			} else if len(schema) == 0 {
+				t.Fatal("Schema() returned empty asset")
+			}
+			if template, err := handler.Template(); err != nil {
+				t.Fatalf("Template() error = %v", err)
+			} else if template == "" {
+				t.Fatal("Template() returned empty asset")
+			}
+		})
+	}
+}
+
+func TestCatalogLookupRejectsUnsupportedSchemaAndTemplate(t *testing.T) {
+	tests := []struct {
+		name       string
+		definition report.Definition
+		want       []string
+	}{
+		{
+			name: "schema",
+			definition: func() report.Definition {
+				definition := report.DefaultRegistry().MustLookup(report.Hourly)
+				definition.GeneratedTextSchemaID = "missing-schema"
+				return definition
+			}(),
+			want: []string{`generated text schema "missing-schema"`, `report "hourly"`},
+		},
+		{
+			name: "template",
+			definition: func() report.Definition {
+				definition := report.DefaultRegistry().MustLookup(report.Hourly)
+				definition.TemplateID = "missing-template"
+				return definition
+			}(),
+			want: []string{`report template "missing-template"`, `report "hourly"`},
+		},
+		{
+			name: "combination",
+			definition: func() report.Definition {
+				definition := report.DefaultRegistry().MustLookup(report.Hourly)
+				definition.TemplateID = "tomorrow"
+				return definition
+			}(),
+			want: []string{`generated text schema "hourly"`, `report template "tomorrow"`, `report "hourly"`},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := LookupDefinition(test.definition)
+			if err == nil {
+				t.Fatal("LookupDefinition() error = nil, want error")
+			}
+			for _, want := range test.want {
+				if !strings.Contains(err.Error(), want) {
+					t.Fatalf("LookupDefinition() error = %v, want %q", err, want)
+				}
+			}
+		})
+	}
+}
+
+func TestCatalogLookupSupportsTodayDefinition(t *testing.T) {
+	definition := report.Definition{
+		ID:                    report.Today,
+		GenerationMode:        report.GenerationModeGeneratedTextTemplate,
+		GeneratedTextSchemaID: "today",
+		TemplateID:            "today",
+	}
+	handler, err := LookupDefinition(definition)
+	if err != nil {
+		t.Fatalf("LookupDefinition(today) error = %v", err)
+	}
+	if handler.SchemaID() != "today" || handler.TemplateID() != "today" {
+		t.Fatalf("handler IDs = %q/%q, want today/today", handler.SchemaID(), handler.TemplateID())
+	}
+	if schema, err := handler.Schema(); err != nil {
+		t.Fatalf("Schema() error = %v", err)
+	} else if len(schema) == 0 {
+		t.Fatal("Schema() returned empty asset")
+	}
+	if template, err := handler.Template(); err != nil {
+		t.Fatalf("Template() error = %v", err)
+	} else if !strings.Contains(template, "# {{ .Report.Title }}") {
+		t.Fatalf("Template() = %q, want Today template source", template)
+	}
+}
+
+func TestCatalogLookupSupportsDailyDefinitionAssets(t *testing.T) {
+	definition := report.Definition{
+		ID:                    report.Daily,
+		GenerationMode:        report.GenerationModeGeneratedTextTemplate,
+		GeneratedTextSchemaID: "daily",
+		TemplateID:            "daily",
+	}
+	handler, err := LookupDefinition(definition)
+	if err != nil {
+		t.Fatalf("LookupDefinition(daily) error = %v", err)
+	}
+	if handler.SchemaID() != "daily" || handler.TemplateID() != "daily" {
+		t.Fatalf("handler IDs = %q/%q, want daily/daily", handler.SchemaID(), handler.TemplateID())
+	}
+	if schema, err := handler.Schema(); err != nil {
+		t.Fatalf("Schema() error = %v", err)
+	} else if len(schema) == 0 {
+		t.Fatal("Schema() returned empty asset")
+	}
+	if template, err := handler.Template(); err != nil {
+		t.Fatalf("Template() error = %v", err)
+	} else if !strings.Contains(template, "# {{ .Report.Title }}") {
+		t.Fatalf("Template() = %q, want Daily template source", template)
+	}
+}
+
+func TestCatalogValidationDispatchSupportsKnownSchemas(t *testing.T) {
+	hourlyHandler, err := LookupDefinition(report.DefaultRegistry().MustLookup(report.Hourly))
+	if err != nil {
+		t.Fatalf("LookupDefinition(hourly) error = %v", err)
+	}
+	hourly, normalized, err := hourlyHandler.Validate([]byte(`{
+		"summary": " Storm chances increase. ",
+		"forecast_discussion": " A front will keep the region unsettled. "
+	}`))
+	if err != nil {
+		t.Fatalf("Validate(hourly) error = %v", err)
+	}
+	if _, ok := hourly.(Hourly); !ok {
+		t.Fatalf("hourly generated text type = %T, want generatedtext.Hourly", hourly)
+	}
+	if !strings.Contains(string(normalized), `"summary":"Storm chances increase."`) {
+		t.Fatalf("hourly normalized text = %s, want trimmed summary", normalized)
+	}
+
+	tomorrowHandler, err := LookupDefinition(report.DefaultRegistry().MustLookup(report.Tomorrow))
+	if err != nil {
+		t.Fatalf("LookupDefinition(tomorrow) error = %v", err)
+	}
+	tomorrow, normalized, err := tomorrowHandler.Validate([]byte(`{
+		"summary": " Storms become more likely tomorrow. ",
+		"forecast_discussion": [" A front will keep showers in the forecast. ", ""]
+	}`))
+	if err != nil {
+		t.Fatalf("Validate(tomorrow) error = %v", err)
+	}
+	if _, ok := tomorrow.(Tomorrow); !ok {
+		t.Fatalf("tomorrow generated text type = %T, want generatedtext.Tomorrow", tomorrow)
+	}
+	if !strings.Contains(string(normalized), `"forecast_discussion":["A front will keep showers in the forecast."]`) {
+		t.Fatalf("tomorrow normalized text = %s, want trimmed discussion paragraph", normalized)
+	}
+
+	todayHandler, err := LookupDefinition(report.Definition{
+		ID:                    report.Today,
+		GenerationMode:        report.GenerationModeGeneratedTextTemplate,
+		GeneratedTextSchemaID: "today",
+		TemplateID:            "today",
+	})
+	if err != nil {
+		t.Fatalf("LookupDefinition(today) error = %v", err)
+	}
+	today, normalized, err := todayHandler.Validate([]byte(`{
+		"summary": " Showers are likely today. ",
+		"forecast_discussion": [" A front will keep rain chances elevated. ", ""]
+	}`))
+	if err != nil {
+		t.Fatalf("Validate(today) error = %v", err)
+	}
+	if _, ok := today.(Today); !ok {
+		t.Fatalf("today generated text type = %T, want generatedtext.Today", today)
+	}
+	if !strings.Contains(string(normalized), `"forecast_discussion":["A front will keep rain chances elevated."]`) {
+		t.Fatalf("today normalized text = %s, want trimmed discussion paragraph", normalized)
+	}
+
+	dailyHandler, err := LookupDefinition(report.Definition{
+		ID:                    report.Daily,
+		GenerationMode:        report.GenerationModeGeneratedTextTemplate,
+		GeneratedTextSchemaID: "daily",
+		TemplateID:            "daily",
+	})
+	if err != nil {
+		t.Fatalf("LookupDefinition(daily) error = %v", err)
+	}
+	daily, normalized, err := dailyHandler.Validate([]byte(`{
+		"summary": " Showers are possible during the selected day. ",
+		"forecast_discussion": [" A front will keep rain chances in the forecast. ", ""]
+	}`))
+	if err != nil {
+		t.Fatalf("Validate(daily) error = %v", err)
+	}
+	if _, ok := daily.(Daily); !ok {
+		t.Fatalf("daily generated text type = %T, want generatedtext.Daily", daily)
+	}
+	if !strings.Contains(string(normalized), `"forecast_discussion":["A front will keep rain chances in the forecast."]`) {
+		t.Fatalf("daily normalized text = %s, want trimmed discussion paragraph", normalized)
+	}
+}
+
+func TestCatalogBuildRenderContextRejectsMismatchedGeneratedText(t *testing.T) {
+	hourlyHandler, err := LookupDefinition(report.DefaultRegistry().MustLookup(report.Hourly))
+	if err != nil {
+		t.Fatalf("LookupDefinition(hourly) error = %v", err)
+	}
+	_, err = hourlyHandler.BuildRenderContext(testMetadata(), testSnapshot(t), testCollected(), testDerived(), Tomorrow{
+		Summary:            "Storms become more likely tomorrow.",
+		ForecastDiscussion: []string{"A front will keep showers in the forecast."},
+	})
+	if err == nil {
+		t.Fatal("BuildRenderContext(hourly) error = nil, want type mismatch")
+	}
+	if !strings.Contains(err.Error(), `requires hourly generated text`) {
+		t.Fatalf("BuildRenderContext(hourly) error = %v, want hourly generated text requirement", err)
+	}
+
+	tomorrowHandler, err := LookupDefinition(report.DefaultRegistry().MustLookup(report.Tomorrow))
+	if err != nil {
+		t.Fatalf("LookupDefinition(tomorrow) error = %v", err)
+	}
+	_, err = tomorrowHandler.BuildRenderContext(testTomorrowMetadata(), testTomorrowSnapshot(t), testCollected(), testTomorrowDerived(), Hourly{
+		Summary:            "Storm chances increase.",
+		ForecastDiscussion: "A front will keep showers in the forecast.",
+	})
+	if err == nil {
+		t.Fatal("BuildRenderContext(tomorrow) error = nil, want type mismatch")
+	}
+	if !strings.Contains(err.Error(), `requires tomorrow generated text`) {
+		t.Fatalf("BuildRenderContext(tomorrow) error = %v, want tomorrow generated text requirement", err)
+	}
+
+	todayHandler, err := LookupDefinition(report.Definition{
+		ID:                    report.Today,
+		GenerationMode:        report.GenerationModeGeneratedTextTemplate,
+		GeneratedTextSchemaID: "today",
+		TemplateID:            "today",
+	})
+	if err != nil {
+		t.Fatalf("LookupDefinition(today) error = %v", err)
+	}
+	_, err = todayHandler.BuildRenderContext(testTodayMetadata(), testTodaySnapshot(t), testCollected(), testTodayDerived(), Tomorrow{
+		Summary:            "Storms become more likely tomorrow.",
+		ForecastDiscussion: []string{"A front will keep showers in the forecast."},
+	})
+	if err == nil {
+		t.Fatal("BuildRenderContext(today) error = nil, want type mismatch")
+	}
+	if !strings.Contains(err.Error(), `requires today generated text`) {
+		t.Fatalf("BuildRenderContext(today) error = %v, want today generated text requirement", err)
+	}
+
+	dailyHandler, err := LookupDefinition(report.Definition{
+		ID:                    report.Daily,
+		GenerationMode:        report.GenerationModeGeneratedTextTemplate,
+		GeneratedTextSchemaID: "daily",
+		TemplateID:            "daily",
+	})
+	if err != nil {
+		t.Fatalf("LookupDefinition(daily) error = %v", err)
+	}
+	_, err = dailyHandler.BuildRenderContext(testDailyMetadata(), testDailySnapshot(t), testCollected(), testDailyDerived(), Tomorrow{
+		Summary:            "Storms become more likely tomorrow.",
+		ForecastDiscussion: []string{"A front will keep showers in the forecast."},
+	})
+	if err == nil {
+		t.Fatal("BuildRenderContext(daily) error = nil, want type mismatch")
+	}
+	if !strings.Contains(err.Error(), `requires daily generated text`) {
+		t.Fatalf("BuildRenderContext(daily) error = %v, want daily generated text requirement", err)
+	}
+}
+
+func TestCatalogBuildRenderContextSupportsDaily(t *testing.T) {
+	handler, err := LookupDefinition(report.Definition{
+		ID:                    report.Daily,
+		GenerationMode:        report.GenerationModeGeneratedTextTemplate,
+		GeneratedTextSchemaID: "daily",
+		TemplateID:            "daily",
+	})
+	if err != nil {
+		t.Fatalf("LookupDefinition(daily) error = %v", err)
+	}
+	ctx, err := handler.BuildRenderContext(testDailyMetadata(), testDailySnapshot(t), testCollected(), testDailyDerived(), Daily{
+		Summary:            "Showers are possible during the selected day.",
+		ForecastDiscussion: []string{"A front will keep rain chances in the forecast."},
+	})
+	if err != nil {
+		t.Fatalf("BuildRenderContext(daily) error = %v", err)
+	}
+	if _, ok := ctx.(DailyRenderContext); !ok {
+		t.Fatalf("BuildRenderContext(daily) = %T, want DailyRenderContext", ctx)
+	}
+}

internal/generatedtext/daily.go

@@ -0,0 +1,28 @@
+package generatedtext
+
+type Daily struct {
+	Summary             string   `json:"summary"`
+	ForecastDiscussion  []string `json:"forecast_discussion"`
+	PrecipitationTiming string   `json:"precipitation_timing,omitempty"`
+	Confidence          string   `json:"confidence,omitempty"`
+}
+
+func ValidateDaily(data []byte) (Daily, []byte, error) {
+	return validateDayStyleGeneratedText[Daily, *Daily](data, "daily")
+}
+
+func (d *Daily) dayStyleFields() dayStyleFields {
+	return dayStyleFields{
+		Summary:             d.Summary,
+		ForecastDiscussion:  d.ForecastDiscussion,
+		PrecipitationTiming: d.PrecipitationTiming,
+		Confidence:          d.Confidence,
+	}
+}
+
+func (d *Daily) setDayStyleFields(fields dayStyleFields) {
+	d.Summary = fields.Summary
+	d.ForecastDiscussion = fields.ForecastDiscussion
+	d.PrecipitationTiming = fields.PrecipitationTiming
+	d.Confidence = fields.Confidence
+}

internal/generatedtext/daily_test.go

@@ -0,0 +1,111 @@
+package generatedtext
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateDailyNormalizesJSON(t *testing.T) {
+	value, normalized, err := ValidateDaily([]byte(`{
+		"summary": " Showers are possible during the selected day. ",
+		"forecast_discussion": [
+			"  A front will keep rain chances in the forecast. ",
+			"",
+			"  Temperatures stay seasonable by afternoon. "
+		],
+		"precipitation_timing": " Rain is most likely during the afternoon. ",
+		"confidence": " Medium "
+	}`))
+	if err != nil {
+		t.Fatalf("ValidateDaily() error = %v", err)
+	}
+	if value.Summary != "Showers are possible during the selected day." {
+		t.Fatalf("Summary = %q, want trimmed summary", value.Summary)
+	}
+	if strings.Join(value.ForecastDiscussion, "|") != "A front will keep rain chances in the forecast.|Temperatures stay seasonable by afternoon." {
+		t.Fatalf("ForecastDiscussion = %#v, want trimmed non-empty paragraphs", value.ForecastDiscussion)
+	}
+	if value.PrecipitationTiming != "Rain is most likely during the afternoon." {
+		t.Fatalf("PrecipitationTiming = %q, want trimmed precipitation timing", value.PrecipitationTiming)
+	}
+	want := `{"summary":"Showers are possible during the selected day.","forecast_discussion":["A front will keep rain chances in the forecast.","Temperatures stay seasonable by afternoon."],"precipitation_timing":"Rain is most likely during the afternoon.","confidence":"Medium"}`
+	if string(normalized) != want {
+		t.Fatalf("normalized = %s, want %s", normalized, want)
+	}
+}
+
+func TestValidateDailyOmitsEmptyOptionalFields(t *testing.T) {
+	_, normalized, err := ValidateDaily([]byte(`{
+		"summary": "Showers are possible during the selected day.",
+		"forecast_discussion": ["A front will keep rain chances in the forecast."],
+		"precipitation_timing": "   ",
+		"confidence": "   "
+	}`))
+	if err != nil {
+		t.Fatalf("ValidateDaily() error = %v", err)
+	}
+	want := `{"summary":"Showers are possible during the selected day.","forecast_discussion":["A front will keep rain chances in the forecast."]}`
+	if string(normalized) != want {
+		t.Fatalf("normalized = %s, want %s", normalized, want)
+	}
+}
+
+func TestValidateDailyRejectsInvalidInput(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "malformed",
+			in:   `{`,
+			want: "decode daily generated text",
+		},
+		{
+			name: "unknown field",
+			in:   `{"summary":"Showers are possible during the selected day.","forecast_discussion":["A front will keep rain chances in the forecast."],"extra":"value"}`,
+			want: `unknown field "extra"`,
+		},
+		{
+			name: "missing summary",
+			in:   `{"forecast_discussion":["A front will keep rain chances in the forecast."]}`,
+			want: "summary is required",
+		},
+		{
+			name: "blank summary",
+			in:   `{"summary":"  ","forecast_discussion":["A front will keep rain chances in the forecast."]}`,
+			want: "summary is required",
+		},
+		{
+			name: "missing forecast discussion",
+			in:   `{"summary":"Showers are possible during the selected day."}`,
+			want: "forecast discussion is required",
+		},
+		{
+			name: "blank forecast discussion",
+			in:   `{"summary":"Showers are possible during the selected day.","forecast_discussion":["  ",""]}`,
+			want: "forecast discussion is required",
+		},
+		{
+			name: "forecast discussion wrong type",
+			in:   `{"summary":"Showers are possible during the selected day.","forecast_discussion":"A front will keep rain chances in the forecast."}`,
+			want: "cannot unmarshal string",
+		},
+		{
+			name: "multiple values",
+			in:   `{"summary":"Showers are possible during the selected day.","forecast_discussion":["A front will keep rain chances in the forecast."]} {}`,
+			want: "multiple JSON values",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, err := ValidateDaily([]byte(test.in))
+			if err == nil {
+				t.Fatal("ValidateDaily() error = nil, want error")
+			}
+			if !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("ValidateDaily() error = %v, want %q", err, test.want)
+			}
+		})
+	}
+}

internal/generatedtext/day_style.go

@@ -0,0 +1,63 @@
+package generatedtext
+
+import (
+	"fmt"
+	"strings"
+)
+
+type dayStyleFields struct {
+	Summary             string
+	ForecastDiscussion  []string
+	PrecipitationTiming string
+	Confidence          string
+}
+
+type dayStyleGeneratedText interface {
+	dayStyleFields() dayStyleFields
+	setDayStyleFields(dayStyleFields)
+}
+
+func validateDayStyleGeneratedText[T any, PT interface {
+	*T
+	dayStyleGeneratedText
+}](data []byte, name string) (T, []byte, error) {
+	value, err := decodeGeneratedText[T](data, name)
+	if err != nil {
+		var zero T
+		return zero, nil, err
+	}
+
+	pointer := PT(&value)
+	fields := pointer.dayStyleFields()
+	fields.Summary = strings.TrimSpace(fields.Summary)
+	fields.PrecipitationTiming = strings.TrimSpace(fields.PrecipitationTiming)
+	fields.Confidence = strings.TrimSpace(fields.Confidence)
+	fields.ForecastDiscussion = trimNonEmpty(fields.ForecastDiscussion)
+	if fields.Summary == "" {
+		var zero T
+		return zero, nil, fmt.Errorf("%s generated text summary is required", name)
+	}
+	if len(fields.ForecastDiscussion) == 0 {
+		var zero T
+		return zero, nil, fmt.Errorf("%s generated text forecast discussion is required", name)
+	}
+	pointer.setDayStyleFields(fields)
+
+	normalized, err := normalizeGeneratedText(value, name)
+	if err != nil {
+		var zero T
+		return zero, nil, err
+	}
+	return value, normalized, nil
+}
+
+func trimNonEmpty(values []string) []string {
+	out := make([]string, 0, len(values))
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed != "" {
+			out = append(out, trimmed)
+		}
+	}
+	return out
+}

internal/generatedtext/day_style_test.go

@@ -0,0 +1,131 @@
+package generatedtext
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestValidateDayStyleGeneratedTextSharedBehavior(t *testing.T) {
+	reports := []struct {
+		name     string
+		validate func([]byte) (any, []byte, error)
+	}{
+		{
+			name: "daily",
+			validate: func(data []byte) (any, []byte, error) {
+				value, normalized, err := ValidateDaily(data)
+				return value, normalized, err
+			},
+		},
+		{
+			name: "today",
+			validate: func(data []byte) (any, []byte, error) {
+				value, normalized, err := ValidateToday(data)
+				return value, normalized, err
+			},
+		},
+		{
+			name: "tomorrow",
+			validate: func(data []byte) (any, []byte, error) {
+				value, normalized, err := ValidateTomorrow(data)
+				return value, normalized, err
+			},
+		},
+	}
+
+	for _, report := range reports {
+		t.Run(report.name, func(t *testing.T) {
+			t.Run("requires summary", func(t *testing.T) {
+				_, _, err := report.validate([]byte(`{"forecast_discussion":["First paragraph."]}`))
+				want := fmt.Sprintf("%s generated text summary is required", report.name)
+				if err == nil || err.Error() != want {
+					t.Fatalf("validate() error = %v, want %q", err, want)
+				}
+			})
+
+			t.Run("requires non-empty forecast discussion", func(t *testing.T) {
+				_, _, err := report.validate([]byte(`{"summary":"Shared summary.","forecast_discussion":["  ",""]}`))
+				want := fmt.Sprintf("%s generated text forecast discussion is required", report.name)
+				if err == nil || err.Error() != want {
+					t.Fatalf("validate() error = %v, want %q", err, want)
+				}
+			})
+
+			t.Run("trims and normalizes", func(t *testing.T) {
+				value, normalized, err := report.validate([]byte(`{
+					"summary": " Shared summary. ",
+					"forecast_discussion": [
+						" First paragraph. ",
+						"",
+						" Second paragraph. "
+					],
+					"precipitation_timing": " Afternoon. ",
+					"confidence": " Medium "
+				}`))
+				if err != nil {
+					t.Fatalf("validate() error = %v", err)
+				}
+				fields := dayStyleFieldsForTest(t, value)
+				if fields.Summary != "Shared summary." {
+					t.Fatalf("Summary = %q, want trimmed summary", fields.Summary)
+				}
+				if strings.Join(fields.ForecastDiscussion, "|") != "First paragraph.|Second paragraph." {
+					t.Fatalf("ForecastDiscussion = %#v, want trimmed non-empty paragraphs", fields.ForecastDiscussion)
+				}
+				if fields.PrecipitationTiming != "Afternoon." {
+					t.Fatalf("PrecipitationTiming = %q, want trimmed precipitation timing", fields.PrecipitationTiming)
+				}
+				if fields.Confidence != "Medium" {
+					t.Fatalf("Confidence = %q, want trimmed confidence", fields.Confidence)
+				}
+				want := `{"summary":"Shared summary.","forecast_discussion":["First paragraph.","Second paragraph."],"precipitation_timing":"Afternoon.","confidence":"Medium"}`
+				if string(normalized) != want {
+					t.Fatalf("normalized = %s, want %s", normalized, want)
+				}
+			})
+
+			t.Run("omits empty optional fields", func(t *testing.T) {
+				_, normalized, err := report.validate([]byte(`{
+					"summary": "Shared summary.",
+					"forecast_discussion": ["First paragraph."],
+					"precipitation_timing": "   ",
+					"confidence": "   "
+				}`))
+				if err != nil {
+					t.Fatalf("validate() error = %v", err)
+				}
+				want := `{"summary":"Shared summary.","forecast_discussion":["First paragraph."]}`
+				if string(normalized) != want {
+					t.Fatalf("normalized = %s, want %s", normalized, want)
+				}
+			})
+
+			t.Run("rejects unknown fields", func(t *testing.T) {
+				_, _, err := report.validate([]byte(`{"summary":"Shared summary.","forecast_discussion":["First paragraph."],"extra":"value"}`))
+				if err == nil {
+					t.Fatal("validate() error = nil, want error")
+				}
+				if !strings.Contains(err.Error(), `unknown field "extra"`) {
+					t.Fatalf("validate() error = %v, want unknown field error", err)
+				}
+			})
+		})
+	}
+}
+
+func dayStyleFieldsForTest(t *testing.T, value any) dayStyleFields {
+	t.Helper()
+
+	switch value := value.(type) {
+	case Daily:
+		return (&value).dayStyleFields()
+	case Today:
+		return (&value).dayStyleFields()
+	case Tomorrow:
+		return (&value).dayStyleFields()
+	default:
+		t.Fatalf("value type = %T, want day-style generated text", value)
+		return dayStyleFields{}
+	}
+}

internal/generatedtext/hourly.go

@@ -2,10 +2,7 @@
 package generatedtext
 
 import (
-	"bytes"
-	"encoding/json"
 	"fmt"
-	"io"
 	"strings"
 )
 
@@ -17,20 +14,9 @@ type Hourly struct {
 }
 
 func ValidateHourly(data []byte) (Hourly, []byte, error) {
-	decoder := json.NewDecoder(bytes.NewReader(data))
-	decoder.DisallowUnknownFields()
-
-	var value Hourly
-	if err := decoder.Decode(&value); err != nil {
-		return Hourly{}, nil, fmt.Errorf("decode hourly generated text: %w", err)
-	}
-	var extra any
-	if err := decoder.Decode(&extra); err != nil {
-		if err != io.EOF {
-			return Hourly{}, nil, fmt.Errorf("decode hourly generated text: %w", err)
-		}
-	} else {
-		return Hourly{}, nil, fmt.Errorf("decode hourly generated text: multiple JSON values")
+	value, err := decodeGeneratedText[Hourly](data, "hourly")
+	if err != nil {
+		return Hourly{}, nil, err
 	}
 
 	value.Summary = strings.TrimSpace(value.Summary)
@@ -44,9 +30,9 @@ func ValidateHourly(data []byte) (Hourly, []byte, error) {
 		return Hourly{}, nil, fmt.Errorf("hourly generated text forecast discussion is required")
 	}
 
-	normalized, err := json.Marshal(value)
+	normalized, err := normalizeGeneratedText(value, "hourly")
 	if err != nil {
-		return Hourly{}, nil, fmt.Errorf("normalize hourly generated text: %w", err)
+		return Hourly{}, nil, err
 	}
 	return value, normalized, nil
 }

internal/generatedtext/json.go

@@ -0,0 +1,33 @@
+package generatedtext
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+func decodeGeneratedText[T any](data []byte, name string) (T, error) {
+	var value T
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	decoder.DisallowUnknownFields()
+	if err := decoder.Decode(&value); err != nil {
+		return value, fmt.Errorf("decode %s generated text: %w", name, err)
+	}
+	var extra any
+	if err := decoder.Decode(&extra); err != nil {
+		if err != io.EOF {
+			return value, fmt.Errorf("decode %s generated text: %w", name, err)
+		}
+		return value, nil
+	}
+	return value, fmt.Errorf("decode %s generated text: multiple JSON values", name)
+}
+
+func normalizeGeneratedText[T any](value T, name string) ([]byte, error) {
+	normalized, err := json.Marshal(value)
+	if err != nil {
+		return nil, fmt.Errorf("normalize %s generated text: %w", name, err)
+	}
+	return normalized, nil
+}

internal/generatedtext/render_context.go

@@ -52,6 +52,54 @@ type TomorrowRenderContext struct {
 	Derived       facts.DerivedFacts
 }
 
+type DailyRenderContext struct {
+	Report        DailyReportContext
+	GeneratedText Daily
+	Modules       DailyTemplateModules
+	Collected     facts.CollectedFacts
+	Derived       facts.DerivedFacts
+}
+
+type TodayRenderContext struct {
+	Report        TodayReportContext
+	GeneratedText Today
+	Modules       TodayTemplateModules
+	Collected     facts.CollectedFacts
+	Derived       facts.DerivedFacts
+}
+
+type TodayReportContext struct {
+	Title             string
+	ForecastDate      time.Time
+	ForecastDateLabel string
+	ForecastDayName   string
+	GeneratedAt       time.Time
+	GeneratedAtLabel  string
+	ValidPeriod       timeutil.Period
+	Timezone          string
+}
+
+type TodayTemplateModules struct {
+	Metadata                *briefing.MetadataModule
+	CurrentConditions       *briefing.CurrentConditionsModule
+	HourlyForecast          *briefing.HourlyForecastModule
+	DerivedDailySummary     *briefing.DerivedDailySummaryModule
+	DerivedDaypartSummaries *map[string]briefing.DerivedDaypartSummaryModule
+	Dayparts                []TodayDaypartContext
+	PrecipTiming            *briefing.PrecipTimingModule
+	AlertDigest             *briefing.AlertDigestModule
+	SPCConvectiveOutlooks   *briefing.SPCConvectiveOutlooksModule
+	AreaForecastDiscussion  *briefing.AreaForecastDiscussionModule
+	SPCConvectiveDiscussion *briefing.SPCConvectiveDiscussionModule
+	WeatherStory            *briefing.WeatherStoryModule
+	TodayPlanning           *briefing.TodayPlanningModule
+}
+
+type TodayDaypartContext struct {
+	Key     string
+	Summary briefing.DerivedDaypartSummaryModule
+}
+
 type TomorrowReportContext struct {
 	Title             string
 	ForecastDate      time.Time
@@ -84,6 +132,64 @@ type TomorrowDaypartContext struct {
 	Summary briefing.DerivedDaypartSummaryModule
 }
 
+type DailyReportContext struct {
+	Title             string
+	ForecastDate      time.Time
+	ForecastDateLabel string
+	ForecastDayName   string
+	GeneratedAt       time.Time
+	GeneratedAtLabel  string
+	ValidPeriod       timeutil.Period
+	Timezone          string
+}
+
+type DailyTemplateModules struct {
+	Metadata                *briefing.MetadataModule
+	CurrentConditions       *briefing.CurrentConditionsModule
+	HourlyForecast          *briefing.HourlyForecastModule
+	DerivedDailySummary     *briefing.DerivedDailySummaryModule
+	DerivedDaypartSummaries *map[string]briefing.DerivedDaypartSummaryModule
+	Dayparts                []DailyDaypartContext
+	PrecipTiming            *briefing.PrecipTimingModule
+	AlertDigest             *briefing.AlertDigestModule
+	SPCConvectiveOutlooks   *briefing.SPCConvectiveOutlooksModule
+	AreaForecastDiscussion  *briefing.AreaForecastDiscussionModule
+	SPCConvectiveDiscussion *briefing.SPCConvectiveDiscussionModule
+	WeatherStory            *briefing.WeatherStoryModule
+	OutdoorWindows          *briefing.OutdoorWindowsModule
+	DailyPlanning           *briefing.DailyPlanningModule
+}
+
+type DailyDaypartContext struct {
+	Key     string
+	Summary briefing.DerivedDaypartSummaryModule
+}
+
+type dayStyleReportContext struct {
+	Title             string
+	ForecastDate      time.Time
+	ForecastDateLabel string
+	ForecastDayName   string
+	GeneratedAt       time.Time
+	GeneratedAtLabel  string
+	ValidPeriod       timeutil.Period
+	Timezone          string
+}
+
+type dayStyleTemplateModules struct {
+	Metadata                *briefing.MetadataModule
+	CurrentConditions       *briefing.CurrentConditionsModule
+	HourlyForecast          *briefing.HourlyForecastModule
+	DerivedDailySummary     *briefing.DerivedDailySummaryModule
+	DerivedDaypartSummaries *map[string]briefing.DerivedDaypartSummaryModule
+	PrecipTiming            *briefing.PrecipTimingModule
+	AlertDigest             *briefing.AlertDigestModule
+	SPCConvectiveOutlooks   *briefing.SPCConvectiveOutlooksModule
+	AreaForecastDiscussion  *briefing.AreaForecastDiscussionModule
+	SPCConvectiveDiscussion *briefing.SPCConvectiveDiscussionModule
+	WeatherStory            *briefing.WeatherStoryModule
+}
+
 func BuildHourlyRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Hourly, collected facts.CollectedFacts, derived facts.DerivedFacts) (HourlyRenderContext, error) {
 	location, err := timeutil.LoadLocation(metadata.Timezone)
 	if err != nil {
@@ -116,34 +222,19 @@ func BuildHourlyRenderContext(metadata briefing.Metadata, snapshot module.Snapsh
 	}, nil
 }
 
-func BuildTomorrowRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Tomorrow, collected facts.CollectedFacts, derived facts.DerivedFacts) (TomorrowRenderContext, error) {
-	location, err := timeutil.LoadLocation(metadata.Timezone)
+func BuildDailyRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Daily, collected facts.CollectedFacts, derived facts.DerivedFacts) (DailyRenderContext, error) {
+	reportContext, err := buildDayStyleReportContext(metadata, "daily", func(dayName string) string {
+		return dayName + "'s Weather"
+	})
 	if err != nil {
-		return TomorrowRenderContext{}, fmt.Errorf("build tomorrow render context: %w", err)
+		return DailyRenderContext{}, err
 	}
-	if metadata.GeneratedAt.IsZero() {
-		return TomorrowRenderContext{}, fmt.Errorf("build tomorrow render context: generatedAt is required")
-	}
-	if !metadata.ValidPeriod.IsValid() {
-		return TomorrowRenderContext{}, fmt.Errorf("build tomorrow render context: valid period is required")
-	}
-	modules, err := tomorrowTemplateModules(snapshot, derived)
+	modules, err := dailyTemplateModules(snapshot, derived)
 	if err != nil {
-		return TomorrowRenderContext{}, err
+		return DailyRenderContext{}, err
 	}
-	forecastDate := metadata.ValidPeriod.Start.In(location)
-	forecastDayName := forecastDate.Format("Monday")
-	return TomorrowRenderContext{
-		Report: TomorrowReportContext{
-			Title:             forecastDayName + "'s Weather",
-			ForecastDate:      forecastDate,
-			ForecastDateLabel: forecastDate.Format("Monday, January 2, 2006"),
-			ForecastDayName:   forecastDayName,
-			GeneratedAt:       metadata.GeneratedAt,
-			GeneratedAtLabel:  generatedAtLabel(metadata.GeneratedAt, location),
-			ValidPeriod:       metadata.ValidPeriod,
-			Timezone:          metadata.Timezone,
-		},
+	return DailyRenderContext{
+		Report:        reportContext.dailyReportContext(),
 		GeneratedText: generated,
 		Modules:       modules,
 		Collected:     collected,
@@ -151,40 +242,203 @@ func BuildTomorrowRenderContext(metadata briefing.Metadata, snapshot module.Snap
 	}, nil
 }
 
+func BuildTodayRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Today, collected facts.CollectedFacts, derived facts.DerivedFacts) (TodayRenderContext, error) {
+	reportContext, err := buildDayStyleReportContext(metadata, "today", func(string) string {
+		return "Today's Weather"
+	})
+	if err != nil {
+		return TodayRenderContext{}, err
+	}
+	modules, err := todayTemplateModules(snapshot, derived)
+	if err != nil {
+		return TodayRenderContext{}, err
+	}
+	return TodayRenderContext{
+		Report:        reportContext.todayReportContext(),
+		GeneratedText: generated,
+		Modules:       modules,
+		Collected:     collected,
+		Derived:       derived,
+	}, nil
+}
+
+func BuildTomorrowRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Tomorrow, collected facts.CollectedFacts, derived facts.DerivedFacts) (TomorrowRenderContext, error) {
+	reportContext, err := buildDayStyleReportContext(metadata, "tomorrow", func(dayName string) string {
+		return dayName + "'s Weather"
+	})
+	if err != nil {
+		return TomorrowRenderContext{}, err
+	}
+	modules, err := tomorrowTemplateModules(snapshot, derived)
+	if err != nil {
+		return TomorrowRenderContext{}, err
+	}
+	return TomorrowRenderContext{
+		Report:        reportContext.tomorrowReportContext(),
+		GeneratedText: generated,
+		Modules:       modules,
+		Collected:     collected,
+		Derived:       derived,
+	}, nil
+}
+
+func buildDayStyleReportContext(metadata briefing.Metadata, name string, title func(string) string) (dayStyleReportContext, error) {
+	location, err := timeutil.LoadLocation(metadata.Timezone)
+	if err != nil {
+		return dayStyleReportContext{}, fmt.Errorf("build %s render context: %w", name, err)
+	}
+	if metadata.GeneratedAt.IsZero() {
+		return dayStyleReportContext{}, fmt.Errorf("build %s render context: generatedAt is required", name)
+	}
+	if !metadata.ValidPeriod.IsValid() {
+		return dayStyleReportContext{}, fmt.Errorf("build %s render context: valid period is required", name)
+	}
+
+	forecastDate := metadata.ValidPeriod.Start.In(location)
+	forecastDayName := forecastDate.Format("Monday")
+	return dayStyleReportContext{
+		Title:             title(forecastDayName),
+		ForecastDate:      forecastDate,
+		ForecastDateLabel: forecastDate.Format("Monday, January 2, 2006"),
+		ForecastDayName:   forecastDayName,
+		GeneratedAt:       metadata.GeneratedAt,
+		GeneratedAtLabel:  generatedAtLabel(metadata.GeneratedAt, location),
+		ValidPeriod:       metadata.ValidPeriod,
+		Timezone:          metadata.Timezone,
+	}, nil
+}
+
+func (ctx dayStyleReportContext) dailyReportContext() DailyReportContext {
+	return DailyReportContext{
+		Title:             ctx.Title,
+		ForecastDate:      ctx.ForecastDate,
+		ForecastDateLabel: ctx.ForecastDateLabel,
+		ForecastDayName:   ctx.ForecastDayName,
+		GeneratedAt:       ctx.GeneratedAt,
+		GeneratedAtLabel:  ctx.GeneratedAtLabel,
+		ValidPeriod:       ctx.ValidPeriod,
+		Timezone:          ctx.Timezone,
+	}
+}
+
+func (ctx dayStyleReportContext) todayReportContext() TodayReportContext {
+	return TodayReportContext{
+		Title:             ctx.Title,
+		ForecastDate:      ctx.ForecastDate,
+		ForecastDateLabel: ctx.ForecastDateLabel,
+		ForecastDayName:   ctx.ForecastDayName,
+		GeneratedAt:       ctx.GeneratedAt,
+		GeneratedAtLabel:  ctx.GeneratedAtLabel,
+		ValidPeriod:       ctx.ValidPeriod,
+		Timezone:          ctx.Timezone,
+	}
+}
+
+func (ctx dayStyleReportContext) tomorrowReportContext() TomorrowReportContext {
+	return TomorrowReportContext{
+		Title:             ctx.Title,
+		ForecastDate:      ctx.ForecastDate,
+		ForecastDateLabel: ctx.ForecastDateLabel,
+		ForecastDayName:   ctx.ForecastDayName,
+		GeneratedAt:       ctx.GeneratedAt,
+		GeneratedAtLabel:  ctx.GeneratedAtLabel,
+		ValidPeriod:       ctx.ValidPeriod,
+		Timezone:          ctx.Timezone,
+	}
+}
+
+func dailyTemplateModules(snapshot module.Snapshot, derived facts.DerivedFacts) (DailyTemplateModules, error) {
+	common, lookup, err := dayStyleTemplateModuleSnapshot(snapshot)
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	outdoor, err := lookup.outdoorWindows()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	planning, err := lookup.dailyPlanning()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	return DailyTemplateModules{
+		Metadata:                common.Metadata,
+		CurrentConditions:       common.CurrentConditions,
+		HourlyForecast:          common.HourlyForecast,
+		DerivedDailySummary:     common.DerivedDailySummary,
+		DerivedDaypartSummaries: common.DerivedDaypartSummaries,
+		Dayparts:                orderedDailyDayparts(common.DerivedDaypartSummaries, derived.DaypartSummaries),
+		PrecipTiming:            common.PrecipTiming,
+		AlertDigest:             common.AlertDigest,
+		SPCConvectiveOutlooks:   common.SPCConvectiveOutlooks,
+		AreaForecastDiscussion:  common.AreaForecastDiscussion,
+		SPCConvectiveDiscussion: common.SPCConvectiveDiscussion,
+		WeatherStory:            common.WeatherStory,
+		OutdoorWindows:          outdoor,
+		DailyPlanning:           planning,
+	}, nil
+}
+
+func todayTemplateModules(snapshot module.Snapshot, derived facts.DerivedFacts) (TodayTemplateModules, error) {
+	common, lookup, err := dayStyleTemplateModuleSnapshot(snapshot)
+	if err != nil {
+		return TodayTemplateModules{}, err
+	}
+	planning, err := lookup.todayPlanning()
+	if err != nil {
+		return TodayTemplateModules{}, err
+	}
+	return TodayTemplateModules{
+		Metadata:                common.Metadata,
+		CurrentConditions:       common.CurrentConditions,
+		HourlyForecast:          common.HourlyForecast,
+		DerivedDailySummary:     common.DerivedDailySummary,
+		DerivedDaypartSummaries: common.DerivedDaypartSummaries,
+		Dayparts:                orderedTodayDayparts(common.DerivedDaypartSummaries, derived.DaypartSummaries),
+		PrecipTiming:            common.PrecipTiming,
+		AlertDigest:             common.AlertDigest,
+		SPCConvectiveOutlooks:   common.SPCConvectiveOutlooks,
+		AreaForecastDiscussion:  common.AreaForecastDiscussion,
+		SPCConvectiveDiscussion: common.SPCConvectiveDiscussion,
+		WeatherStory:            common.WeatherStory,
+		TodayPlanning:           planning,
+	}, nil
+}
+
 func hourlyTemplateModules(snapshot module.Snapshot) (HourlyTemplateModules, error) {
-	metadata, err := optionalStanza[briefing.MetadataModule](snapshot, string(module.Metadata))
+	lookup := newModuleSnapshotLookup(snapshot)
+	metadata, err := lookup.metadata()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	current, err := optionalStanza[briefing.CurrentConditionsModule](snapshot, string(module.CurrentConditions))
+	current, err := lookup.currentConditions()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	hourly, err := optionalStanza[briefing.HourlyForecastModule](snapshot, string(module.HourlyForecast))
+	hourly, err := lookup.hourlyForecast()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	precip, err := optionalStanza[briefing.PrecipTimingModule](snapshot, string(module.PrecipTiming))
+	precip, err := lookup.precipTiming()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	alerts, err := optionalStanza[briefing.AlertDigestModule](snapshot, string(module.AlertDigest))
+	alerts, err := lookup.alertDigest()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	outlooks, err := optionalStanza[briefing.SPCConvectiveOutlooksModule](snapshot, string(module.SPCConvectiveOutlooks))
+	outlooks, err := lookup.spcConvectiveOutlooks()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	discussion, err := optionalStanza[briefing.AreaForecastDiscussionModule](snapshot, string(module.AreaForecastDiscussion))
+	discussion, err := lookup.areaForecastDiscussion()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	spcDiscussion, err := optionalStanza[briefing.SPCConvectiveDiscussionModule](snapshot, string(module.SPCConvectiveDiscussion))
+	spcDiscussion, err := lookup.spcConvectiveDiscussion()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
-	story, err := optionalStanza[briefing.WeatherStoryModule](snapshot, string(module.WeatherStory))
+	story, err := lookup.weatherStory()
 	if err != nil {
 		return HourlyTemplateModules{}, err
 	}
@@ -202,88 +456,218 @@ func hourlyTemplateModules(snapshot module.Snapshot) (HourlyTemplateModules, err
 }
 
 func tomorrowTemplateModules(snapshot module.Snapshot, derived facts.DerivedFacts) (TomorrowTemplateModules, error) {
-	metadata, err := optionalStanza[briefing.MetadataModule](snapshot, string(module.Metadata))
+	common, lookup, err := dayStyleTemplateModuleSnapshot(snapshot)
 	if err != nil {
 		return TomorrowTemplateModules{}, err
 	}
-	current, err := optionalStanza[briefing.CurrentConditionsModule](snapshot, string(module.CurrentConditions))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	hourly, err := optionalStanza[briefing.HourlyForecastModule](snapshot, string(module.HourlyForecast))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	daily, err := optionalStanza[briefing.DerivedDailySummaryModule](snapshot, string(module.DerivedDailySummary))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	dayparts, err := optionalStanza[map[string]briefing.DerivedDaypartSummaryModule](snapshot, string(module.DerivedDaypartSummaries))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	precip, err := optionalStanza[briefing.PrecipTimingModule](snapshot, string(module.PrecipTiming))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	alerts, err := optionalStanza[briefing.AlertDigestModule](snapshot, string(module.AlertDigest))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	outlooks, err := optionalStanza[briefing.SPCConvectiveOutlooksModule](snapshot, string(module.SPCConvectiveOutlooks))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	discussion, err := optionalStanza[briefing.AreaForecastDiscussionModule](snapshot, string(module.AreaForecastDiscussion))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	spcDiscussion, err := optionalStanza[briefing.SPCConvectiveDiscussionModule](snapshot, string(module.SPCConvectiveDiscussion))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	story, err := optionalStanza[briefing.WeatherStoryModule](snapshot, string(module.WeatherStory))
-	if err != nil {
-		return TomorrowTemplateModules{}, err
-	}
-	planning, err := optionalStanza[briefing.TomorrowPlanningModule](snapshot, string(module.TomorrowPlanning))
+	planning, err := lookup.tomorrowPlanning()
 	if err != nil {
 		return TomorrowTemplateModules{}, err
 	}
 	return TomorrowTemplateModules{
+		Metadata:                common.Metadata,
+		CurrentConditions:       common.CurrentConditions,
+		HourlyForecast:          common.HourlyForecast,
+		DerivedDailySummary:     common.DerivedDailySummary,
+		DerivedDaypartSummaries: common.DerivedDaypartSummaries,
+		Dayparts:                orderedTomorrowDayparts(common.DerivedDaypartSummaries, derived.DaypartSummaries),
+		PrecipTiming:            common.PrecipTiming,
+		AlertDigest:             common.AlertDigest,
+		SPCConvectiveOutlooks:   common.SPCConvectiveOutlooks,
+		AreaForecastDiscussion:  common.AreaForecastDiscussion,
+		SPCConvectiveDiscussion: common.SPCConvectiveDiscussion,
+		WeatherStory:            common.WeatherStory,
+		TomorrowPlanning:        planning,
+	}, nil
+}
+
+func dayStyleTemplateModuleSnapshot(snapshot module.Snapshot) (dayStyleTemplateModules, moduleSnapshotLookup, error) {
+	lookup := newModuleSnapshotLookup(snapshot)
+	metadata, err := lookup.metadata()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	current, err := lookup.currentConditions()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	hourly, err := lookup.hourlyForecast()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	daily, err := lookup.derivedDailySummary()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	dayparts, err := lookup.derivedDaypartSummaries()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	precip, err := lookup.precipTiming()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	alerts, err := lookup.alertDigest()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	outlooks, err := lookup.spcConvectiveOutlooks()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	discussion, err := lookup.areaForecastDiscussion()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	spcDiscussion, err := lookup.spcConvectiveDiscussion()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	story, err := lookup.weatherStory()
+	if err != nil {
+		return dayStyleTemplateModules{}, moduleSnapshotLookup{}, err
+	}
+	return dayStyleTemplateModules{
 		Metadata:                metadata,
 		CurrentConditions:       current,
 		HourlyForecast:          hourly,
 		DerivedDailySummary:     daily,
 		DerivedDaypartSummaries: dayparts,
-		Dayparts:                orderedTomorrowDayparts(dayparts, derived.DaypartSummaries),
 		PrecipTiming:            precip,
 		AlertDigest:             alerts,
 		SPCConvectiveOutlooks:   outlooks,
 		AreaForecastDiscussion:  discussion,
 		SPCConvectiveDiscussion: spcDiscussion,
 		WeatherStory:            story,
-		TomorrowPlanning:        planning,
-	}, nil
+	}, lookup, nil
 }
 
-func optionalStanza[T any](snapshot module.Snapshot, name string) (*T, error) {
-	output, ok := snapshot.LookupStanza(name)
+type moduleSnapshotLookup struct {
+	snapshot module.Snapshot
+	stanzas  map[string]module.Output
+}
+
+func newModuleSnapshotLookup(snapshot module.Snapshot) moduleSnapshotLookup {
+	stanzas := make(map[string]module.Output, len(snapshot.Outputs))
+	for _, output := range snapshot.Outputs {
+		stanzas[output.StanzaName] = output
+	}
+	return moduleSnapshotLookup{
+		snapshot: snapshot,
+		stanzas:  stanzas,
+	}
+}
+
+func (lookup moduleSnapshotLookup) metadata() (*briefing.MetadataModule, error) {
+	return optionalStanza[briefing.MetadataModule](lookup, module.Metadata)
+}
+
+func (lookup moduleSnapshotLookup) currentConditions() (*briefing.CurrentConditionsModule, error) {
+	return optionalStanza[briefing.CurrentConditionsModule](lookup, module.CurrentConditions)
+}
+
+func (lookup moduleSnapshotLookup) hourlyForecast() (*briefing.HourlyForecastModule, error) {
+	return optionalStanza[briefing.HourlyForecastModule](lookup, module.HourlyForecast)
+}
+
+func (lookup moduleSnapshotLookup) derivedDailySummary() (*briefing.DerivedDailySummaryModule, error) {
+	return optionalStanza[briefing.DerivedDailySummaryModule](lookup, module.DerivedDailySummary)
+}
+
+func (lookup moduleSnapshotLookup) derivedDaypartSummaries() (*map[string]briefing.DerivedDaypartSummaryModule, error) {
+	return optionalStanza[map[string]briefing.DerivedDaypartSummaryModule](lookup, module.DerivedDaypartSummaries)
+}
+
+func (lookup moduleSnapshotLookup) precipTiming() (*briefing.PrecipTimingModule, error) {
+	return optionalStanza[briefing.PrecipTimingModule](lookup, module.PrecipTiming)
+}
+
+func (lookup moduleSnapshotLookup) alertDigest() (*briefing.AlertDigestModule, error) {
+	return optionalStanza[briefing.AlertDigestModule](lookup, module.AlertDigest)
+}
+
+func (lookup moduleSnapshotLookup) spcConvectiveOutlooks() (*briefing.SPCConvectiveOutlooksModule, error) {
+	return optionalStanza[briefing.SPCConvectiveOutlooksModule](lookup, module.SPCConvectiveOutlooks)
+}
+
+func (lookup moduleSnapshotLookup) areaForecastDiscussion() (*briefing.AreaForecastDiscussionModule, error) {
+	return optionalStanza[briefing.AreaForecastDiscussionModule](lookup, module.AreaForecastDiscussion)
+}
+
+func (lookup moduleSnapshotLookup) spcConvectiveDiscussion() (*briefing.SPCConvectiveDiscussionModule, error) {
+	return optionalStanza[briefing.SPCConvectiveDiscussionModule](lookup, module.SPCConvectiveDiscussion)
+}
+
+func (lookup moduleSnapshotLookup) weatherStory() (*briefing.WeatherStoryModule, error) {
+	return optionalStanza[briefing.WeatherStoryModule](lookup, module.WeatherStory)
+}
+
+func (lookup moduleSnapshotLookup) outdoorWindows() (*briefing.OutdoorWindowsModule, error) {
+	return optionalStanza[briefing.OutdoorWindowsModule](lookup, module.OutdoorWindows)
+}
+
+func (lookup moduleSnapshotLookup) dailyPlanning() (*briefing.DailyPlanningModule, error) {
+	return optionalStanza[briefing.DailyPlanningModule](lookup, module.DailyPlanning)
+}
+
+func (lookup moduleSnapshotLookup) todayPlanning() (*briefing.TodayPlanningModule, error) {
+	return optionalStanza[briefing.TodayPlanningModule](lookup, module.TodayPlanning)
+}
+
+func (lookup moduleSnapshotLookup) tomorrowPlanning() (*briefing.TomorrowPlanningModule, error) {
+	return optionalStanza[briefing.TomorrowPlanningModule](lookup, module.TomorrowPlanning)
+}
+
+func optionalStanza[T any](lookup moduleSnapshotLookup, id module.ID) (*T, error) {
+	name := string(id)
+	output, ok := lookup.stanzas[name]
 	if !ok || output.Value == nil {
 		return nil, nil
 	}
-	value, _, err := module.StanzaValue[T](snapshot, name)
+	value, _, err := module.StanzaValue[T](lookup.snapshot, name)
 	if err != nil {
-		return nil, fmt.Errorf("build render context: %w", err)
+		return nil, fmt.Errorf("build render context module %q: %w", id, err)
 	}
 	return &value, nil
 }
 
+func orderedTodayDayparts(dayparts *map[string]briefing.DerivedDaypartSummaryModule, ordered []forecast.DaypartSummary) []TodayDaypartContext {
+	orderedRows := orderedDaypartRows(dayparts, ordered)
+	out := make([]TodayDaypartContext, 0, len(orderedRows))
+	for _, row := range orderedRows {
+		out = append(out, TodayDaypartContext{Key: row.Key, Summary: row.Summary})
+	}
+	return out
+}
+
+func orderedDailyDayparts(dayparts *map[string]briefing.DerivedDaypartSummaryModule, ordered []forecast.DaypartSummary) []DailyDaypartContext {
+	orderedRows := orderedDaypartRows(dayparts, ordered)
+	out := make([]DailyDaypartContext, 0, len(orderedRows))
+	for _, row := range orderedRows {
+		out = append(out, DailyDaypartContext{Key: row.Key, Summary: row.Summary})
+	}
+	return out
+}
+
 func orderedTomorrowDayparts(dayparts *map[string]briefing.DerivedDaypartSummaryModule, ordered []forecast.DaypartSummary) []TomorrowDaypartContext {
+	orderedRows := orderedDaypartRows(dayparts, ordered)
+	out := make([]TomorrowDaypartContext, 0, len(orderedRows))
+	for _, row := range orderedRows {
+		out = append(out, TomorrowDaypartContext{Key: row.Key, Summary: row.Summary})
+	}
+	return out
+}
+
+type orderedDaypartRow struct {
+	Key     string
+	Summary briefing.DerivedDaypartSummaryModule
+}
+
+func orderedDaypartRows(dayparts *map[string]briefing.DerivedDaypartSummaryModule, ordered []forecast.DaypartSummary) []orderedDaypartRow {
 	if dayparts == nil || len(*dayparts) == 0 {
 		return nil
 	}
-	out := make([]TomorrowDaypartContext, 0, len(*dayparts))
+	out := make([]orderedDaypartRow, 0, len(*dayparts))
 	seen := map[string]struct{}{}
 	for _, daypart := range ordered {
 		for _, key := range daypartModuleKeyCandidates(daypart) {
@@ -295,7 +679,7 @@ func orderedTomorrowDayparts(dayparts *map[string]briefing.DerivedDaypartSummary
 				continue
 			}
 			seen[key] = struct{}{}
-			out = append(out, TomorrowDaypartContext{Key: key, Summary: value})
+			out = append(out, orderedDaypartRow{Key: key, Summary: value})
 			break
 		}
 	}
@@ -308,7 +692,7 @@ func orderedTomorrowDayparts(dayparts *map[string]briefing.DerivedDaypartSummary
 	}
 	sort.Strings(remaining)
 	for _, key := range remaining {
-		out = append(out, TomorrowDaypartContext{Key: key, Summary: (*dayparts)[key]})
+		out = append(out, orderedDaypartRow{Key: key, Summary: (*dayparts)[key]})
 	}
 	return out
 }

internal/generatedtext/render_context_test.go

@@ -44,12 +44,18 @@ func TestBuildHourlyRenderContext(t *testing.T) {
 	if ctx.Modules.CurrentConditions == nil || ctx.Modules.CurrentConditions.ConditionText != "Partly cloudy" || ctx.Modules.CurrentConditions.TemperatureF == nil || *ctx.Modules.CurrentConditions.TemperatureF != 74 {
 		t.Fatalf("Modules.CurrentConditions = %#v, want structured current conditions", ctx.Modules.CurrentConditions)
 	}
+	if ctx.Modules.CurrentConditions.ConditionTextLower != "partly cloudy" || ctx.Modules.CurrentConditions.WindDirectionText != "south" {
+		t.Fatalf("Modules.CurrentConditions helpers = %#v, want rich template helper fields", ctx.Modules.CurrentConditions)
+	}
 	if ctx.Modules.HourlyForecast == nil || len(ctx.Modules.HourlyForecast.Periods) != 2 {
 		t.Fatalf("Modules.HourlyForecast = %#v, want 2 periods", ctx.Modules.HourlyForecast)
 	}
 	if period := ctx.Modules.HourlyForecast.Periods[1]; period.PeriodBegins != "2026-05-29 at 10:00 AM" || period.TextDescription != "Showers" || period.ProbabilityOfPrecipitationPercent == nil || *period.ProbabilityOfPrecipitationPercent != 70 {
 		t.Fatalf("Modules.HourlyForecast.Periods[1] = %#v, want 10 AM showers row", period)
 	}
+	if period := ctx.Modules.HourlyForecast.Periods[1]; period.HourLabel != "10:00 AM" || period.TextDescriptionLower != "showers" || !period.MentionPrecipitation {
+		t.Fatalf("Modules.HourlyForecast.Periods[1] helpers = %#v, want rich template helper fields", period)
+	}
 	if ctx.Modules.PrecipTiming == nil || ctx.Modules.PrecipTiming.MaxPopPercent == nil || *ctx.Modules.PrecipTiming.MaxPopPercent != 70 {
 		t.Fatalf("Modules.PrecipTiming = %#v, want max pop", ctx.Modules.PrecipTiming)
 	}
@@ -85,7 +91,7 @@ func TestBuildHourlyRenderContext(t *testing.T) {
 		"**Updated:** Friday, May 29, 2026 at 8:30 AM",
 		"Storm chances increase through late morning.",
 		"- **10:00 AM:** 75°F and showers. Probability of precipitation is 70%.",
-		"- **Flood Watch**: Flood Watch until early afternoon",
+		"- **Flood Watch**: Flood Watch in effect from May 29 at 10:00 AM to May 29 at 2:30 PM. Avoid low-water crossings.",
 		"A cold front is moving into the region.",
 		"A front will keep the region unsettled.",
 	} {
@@ -109,8 +115,478 @@ func TestBuildHourlyRenderContextAllowsOmittedOptionalModules(t *testing.T) {
 	if err != nil {
 		t.Fatalf("BuildHourlyRenderContext() error = %v", err)
 	}
-	if ctx.Modules.HourlyForecast != nil {
-		t.Fatalf("Modules.HourlyForecast = %#v, want nil for omitted module", ctx.Modules.HourlyForecast)
+	if ctx.Modules.CurrentConditions == nil {
+		t.Fatal("Modules.CurrentConditions = nil, want populated module")
+	}
+	if ctx.Modules.HourlyForecast != nil || ctx.Modules.PrecipTiming != nil || ctx.Modules.AlertDigest != nil {
+		t.Fatalf("Modules = %#v, want omitted optional modules to remain nil", ctx.Modules)
+	}
+}
+
+func TestBuildRenderContextReportsModuleExtractionError(t *testing.T) {
+	snapshot, err := module.NewSnapshot([]module.Output{
+		{ID: module.CurrentConditions, StanzaName: string(module.CurrentConditions), Value: "not a current conditions stanza"},
+	})
+	if err != nil {
+		t.Fatalf("NewSnapshot() error = %v", err)
+	}
+	_, err = BuildHourlyRenderContext(testMetadata(), snapshot, Hourly{
+		Summary:            "Storm chances increase.",
+		ForecastDiscussion: "A front will keep the region unsettled.",
+	}, testCollected(), facts.DerivedFacts{})
+	if err == nil {
+		t.Fatal("BuildHourlyRenderContext() error = nil, want extraction error")
+	}
+	if !strings.Contains(err.Error(), string(module.CurrentConditions)) {
+		t.Fatalf("BuildHourlyRenderContext() error = %v, want module ID", err)
+	}
+}
+
+func TestBuildTodayRenderContext(t *testing.T) {
+	metadata := testTodayMetadata()
+	snapshot := testTodaySnapshot(t)
+	generated := Today{
+		Summary: "Today starts quiet, then showers become more likely later in the day.",
+		ForecastDiscussion: []string{
+			"Morning conditions should stay mostly dry.",
+			"Rain chances increase during the afternoon as deeper moisture arrives.",
+		},
+		PrecipitationTiming: "The most likely rain window is from midafternoon into early evening.",
+	}
+	collected := testCollected()
+	derived := testTodayDerived()
+
+	ctx, err := BuildTodayRenderContext(metadata, snapshot, generated, collected, derived)
+	if err != nil {
+		t.Fatalf("BuildTodayRenderContext() error = %v", err)
+	}
+	if ctx.Report.Title != "Today's Weather" {
+		t.Fatalf("Report.Title = %q, want Today's Weather", ctx.Report.Title)
+	}
+	if ctx.Report.ForecastDateLabel != "Monday, June 15, 2026" || ctx.Report.ForecastDayName != "Monday" {
+		t.Fatalf("forecast date labels = %q/%q, want Monday labels", ctx.Report.ForecastDateLabel, ctx.Report.ForecastDayName)
+	}
+	if ctx.Report.GeneratedAtLabel != "Monday, June 15, 2026 at 7:14 AM" {
+		t.Fatalf("Report.GeneratedAtLabel = %q, want friendly generated-at label", ctx.Report.GeneratedAtLabel)
+	}
+	if ctx.Modules.Metadata == nil || ctx.Modules.Metadata.ReportID != report.Today {
+		t.Fatalf("Modules.Metadata = %#v, want today metadata", ctx.Modules.Metadata)
+	}
+	if ctx.Modules.CurrentConditions == nil || ctx.Modules.HourlyForecast == nil {
+		t.Fatalf("current/hourly modules = %#v/%#v, want available in render context", ctx.Modules.CurrentConditions, ctx.Modules.HourlyForecast)
+	}
+	if ctx.Modules.DerivedDailySummary == nil || ctx.Modules.DerivedDailySummary.HighTempF == nil || *ctx.Modules.DerivedDailySummary.HighTempF != 74 {
+		t.Fatalf("Modules.DerivedDailySummary = %#v, want daily summary", ctx.Modules.DerivedDailySummary)
+	}
+	if ctx.Modules.DerivedDaypartSummaries == nil || len(*ctx.Modules.DerivedDaypartSummaries) != 2 {
+		t.Fatalf("Modules.DerivedDaypartSummaries = %#v, want daypart map", ctx.Modules.DerivedDaypartSummaries)
+	}
+	if len(ctx.Modules.Dayparts) != 2 || ctx.Modules.Dayparts[0].Key != "morning" || ctx.Modules.Dayparts[1].Key != "afternoon" {
+		t.Fatalf("Modules.Dayparts = %#v, want configured order", ctx.Modules.Dayparts)
+	}
+	if morning := (*ctx.Modules.DerivedDaypartSummaries)["morning"]; morning.DominantConditionDisplay == "" || morning.DominantConditionLower == "" || morning.TemperatureSteadyPhraseF == "" {
+		t.Fatalf("today rich morning daypart helpers = %#v, want render-context helper fields", morning)
+	}
+	if afternoon := (*ctx.Modules.DerivedDaypartSummaries)["afternoon"]; afternoon.MaxPopTimeLabel != "3:00 PM" {
+		t.Fatalf("today rich afternoon daypart = %#v, want max pop time label helper", afternoon)
+	}
+	if ctx.Modules.PrecipTiming == nil || len(ctx.Modules.PrecipTiming.PrecipitationWindows) != 1 {
+		t.Fatalf("Modules.PrecipTiming = %#v, want precipitation window", ctx.Modules.PrecipTiming)
+	}
+	if ctx.Modules.AlertDigest == nil || ctx.Modules.SPCConvectiveOutlooks == nil || ctx.Modules.AreaForecastDiscussion == nil || ctx.Modules.SPCConvectiveDiscussion == nil || ctx.Modules.WeatherStory == nil || ctx.Modules.TodayPlanning == nil {
+		t.Fatalf("optional modules missing from render context: %#v", ctx.Modules)
+	}
+	if ctx.Modules.TodayPlanning.MorningReadiness[0] != "Take sunglasses early." {
+		t.Fatalf("Modules.TodayPlanning = %#v, want today planning facts", ctx.Modules.TodayPlanning)
+	}
+	if !ctx.Collected.FetchedAt.Equal(collected.FetchedAt) {
+		t.Fatalf("Collected.FetchedAt = %s, want %s", ctx.Collected.FetchedAt, collected.FetchedAt)
+	}
+	if len(ctx.Derived.DaypartSummaries) != 2 {
+		t.Fatalf("Derived.DaypartSummaries = %#v, want passthrough facts", ctx.Derived.DaypartSummaries)
+	}
+
+	rendered, err := reporttemplate.Render("today", ctx)
+	if err != nil {
+		t.Fatalf("Render() error = %v", err)
+	}
+	text := string(rendered)
+	for _, want := range []string{
+		"# Today's Weather",
+		"**Forecast date:** Monday, June 15, 2026",
+		"Today starts quiet, then showers become more likely later in the day.",
+		"Currently, it is 58°F and clear. It feels like 57°F, with a relative humidity of 61% and winds from the northwest at 9 mph.",
+		"- **Morning:** Partly cloudy, with temperatures in the low 60s.",
+		"- **Afternoon:** Showers, with temperatures in the mid 70s. Chance of precipitation is 70%.",
+		"## Precipitation Timing",
+		"- **3:00 PM** to **6:00 PM**: Expect showers. The peak precipitation chance is 70% at 3:00 PM.",
+		"The most likely rain window is from midafternoon into early evening.",
+		"Morning conditions should stay mostly dry.",
+		"Rain chances increase during the afternoon as deeper moisture arrives.",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("rendered template missing %q:\n%s", want, text)
+		}
+	}
+	assertOrderedText(t, text, []string{
+		"# Today's Weather",
+		"## Current Conditions",
+		"## Daypart Forecast",
+		"- **Morning:**",
+		"- **Afternoon:**",
+		"## Precipitation Timing",
+		"## Forecast Discussion",
+	})
+	if strings.Contains(text, "## Planning Notes") || strings.Contains(text, "- Take sunglasses early.") || strings.Contains(text, "Forecast details are limited") {
+		t.Fatalf("rendered template included removed Today template content:\n%s", text)
+	}
+}
+
+func TestBuildTodayRenderContextAllowsOmittedOptionalModules(t *testing.T) {
+	snapshot, err := module.NewSnapshot(nil)
+	if err != nil {
+		t.Fatalf("NewSnapshot() error = %v", err)
+	}
+	ctx, err := BuildTodayRenderContext(testTodayMetadata(), snapshot, Today{
+		Summary:            "Dry weather is expected today.",
+		ForecastDiscussion: []string{"High pressure keeps conditions quiet."},
+	}, testCollected(), facts.DerivedFacts{})
+	if err != nil {
+		t.Fatalf("BuildTodayRenderContext() error = %v", err)
+	}
+	if ctx.Modules.Metadata != nil || ctx.Modules.CurrentConditions != nil || ctx.Modules.PrecipTiming != nil || len(ctx.Modules.Dayparts) != 0 || ctx.Modules.TodayPlanning != nil {
+		t.Fatalf("Modules = %#v, want omitted optional modules", ctx.Modules)
+	}
+	rendered, err := reporttemplate.Render("today", ctx)
+	if err != nil {
+		t.Fatalf("Render() error = %v", err)
+	}
+	text := string(rendered)
+	for _, unwanted := range []string{"## Current Conditions", "## Precipitation Timing", "## Planning Notes", "Forecast details are limited"} {
+		if strings.Contains(text, unwanted) {
+			t.Fatalf("rendered template included %q without module data:\n%s", unwanted, text)
+		}
+	}
+	if !strings.Contains(text, "- No daypart forecast details are available.") {
+		t.Fatalf("rendered template missing daypart fallback:\n%s", text)
+	}
+}
+
+func TestBuildDayStyleRenderContextsPopulateSharedFieldsAndPlanningModules(t *testing.T) {
+	type result struct {
+		title             string
+		forecastDateLabel string
+		generatedAtLabel  string
+		timezone          string
+		validPeriod       timeutil.Period
+		metadata          bool
+		current           bool
+		hourly            bool
+		dailySummary      bool
+		daypartSummaries  bool
+		dayparts          int
+		precip            bool
+		alerts            bool
+		outlooks          bool
+		discussion        bool
+		spcDiscussion     bool
+		story             bool
+		planning          bool
+		collected         bool
+		derived           bool
+	}
+	tests := []struct {
+		name               string
+		wantTitle          string
+		wantGeneratedLabel string
+		wantDayparts       int
+		build              func(t *testing.T) result
+	}{
+		{
+			name:               "daily",
+			wantTitle:          "Monday's Weather",
+			wantGeneratedLabel: "Saturday, June 13, 2026 at 9:14 AM",
+			wantDayparts:       3,
+			build: func(t *testing.T) result {
+				t.Helper()
+				collected := testCollected()
+				derived := testDailyDerived()
+				ctx, err := BuildDailyRenderContext(testDailyMetadata(), testDailySnapshot(t), Daily{
+					Summary:            "Daily summary.",
+					ForecastDiscussion: []string{"Daily discussion."},
+				}, collected, derived)
+				if err != nil {
+					t.Fatalf("BuildDailyRenderContext() error = %v", err)
+				}
+				return result{
+					title:             ctx.Report.Title,
+					forecastDateLabel: ctx.Report.ForecastDateLabel,
+					generatedAtLabel:  ctx.Report.GeneratedAtLabel,
+					timezone:          ctx.Report.Timezone,
+					validPeriod:       ctx.Report.ValidPeriod,
+					metadata:          ctx.Modules.Metadata != nil && ctx.Modules.Metadata.ReportID == report.Daily,
+					current:           ctx.Modules.CurrentConditions != nil,
+					hourly:            ctx.Modules.HourlyForecast != nil,
+					dailySummary:      ctx.Modules.DerivedDailySummary != nil,
+					daypartSummaries:  ctx.Modules.DerivedDaypartSummaries != nil,
+					dayparts:          len(ctx.Modules.Dayparts),
+					precip:            ctx.Modules.PrecipTiming != nil,
+					alerts:            ctx.Modules.AlertDigest != nil,
+					outlooks:          ctx.Modules.SPCConvectiveOutlooks != nil,
+					discussion:        ctx.Modules.AreaForecastDiscussion != nil,
+					spcDiscussion:     ctx.Modules.SPCConvectiveDiscussion != nil,
+					story:             ctx.Modules.WeatherStory != nil,
+					planning:          ctx.Modules.DailyPlanning != nil,
+					collected:         ctx.Collected.FetchedAt.Equal(collected.FetchedAt),
+					derived:           len(ctx.Derived.DaypartSummaries) == len(derived.DaypartSummaries),
+				}
+			},
+		},
+		{
+			name:               "today",
+			wantTitle:          "Today's Weather",
+			wantGeneratedLabel: "Monday, June 15, 2026 at 7:14 AM",
+			wantDayparts:       2,
+			build: func(t *testing.T) result {
+				t.Helper()
+				collected := testCollected()
+				derived := testTodayDerived()
+				ctx, err := BuildTodayRenderContext(testTodayMetadata(), testTodaySnapshot(t), Today{
+					Summary:            "Today summary.",
+					ForecastDiscussion: []string{"Today discussion."},
+				}, collected, derived)
+				if err != nil {
+					t.Fatalf("BuildTodayRenderContext() error = %v", err)
+				}
+				return result{
+					title:             ctx.Report.Title,
+					forecastDateLabel: ctx.Report.ForecastDateLabel,
+					generatedAtLabel:  ctx.Report.GeneratedAtLabel,
+					timezone:          ctx.Report.Timezone,
+					validPeriod:       ctx.Report.ValidPeriod,
+					metadata:          ctx.Modules.Metadata != nil && ctx.Modules.Metadata.ReportID == report.Today,
+					current:           ctx.Modules.CurrentConditions != nil,
+					hourly:            ctx.Modules.HourlyForecast != nil,
+					dailySummary:      ctx.Modules.DerivedDailySummary != nil,
+					daypartSummaries:  ctx.Modules.DerivedDaypartSummaries != nil,
+					dayparts:          len(ctx.Modules.Dayparts),
+					precip:            ctx.Modules.PrecipTiming != nil,
+					alerts:            ctx.Modules.AlertDigest != nil,
+					outlooks:          ctx.Modules.SPCConvectiveOutlooks != nil,
+					discussion:        ctx.Modules.AreaForecastDiscussion != nil,
+					spcDiscussion:     ctx.Modules.SPCConvectiveDiscussion != nil,
+					story:             ctx.Modules.WeatherStory != nil,
+					planning:          ctx.Modules.TodayPlanning != nil,
+					collected:         ctx.Collected.FetchedAt.Equal(collected.FetchedAt),
+					derived:           len(ctx.Derived.DaypartSummaries) == len(derived.DaypartSummaries),
+				}
+			},
+		},
+		{
+			name:               "tomorrow",
+			wantTitle:          "Monday's Weather",
+			wantGeneratedLabel: "Sunday, June 14, 2026 at 9:14 AM",
+			wantDayparts:       2,
+			build: func(t *testing.T) result {
+				t.Helper()
+				collected := testCollected()
+				derived := testTomorrowDerived()
+				ctx, err := BuildTomorrowRenderContext(testTomorrowMetadata(), testTomorrowSnapshot(t), Tomorrow{
+					Summary:            "Tomorrow summary.",
+					ForecastDiscussion: []string{"Tomorrow discussion."},
+				}, collected, derived)
+				if err != nil {
+					t.Fatalf("BuildTomorrowRenderContext() error = %v", err)
+				}
+				return result{
+					title:             ctx.Report.Title,
+					forecastDateLabel: ctx.Report.ForecastDateLabel,
+					generatedAtLabel:  ctx.Report.GeneratedAtLabel,
+					timezone:          ctx.Report.Timezone,
+					validPeriod:       ctx.Report.ValidPeriod,
+					metadata:          ctx.Modules.Metadata != nil && ctx.Modules.Metadata.ReportID == report.Tomorrow,
+					current:           ctx.Modules.CurrentConditions != nil,
+					hourly:            ctx.Modules.HourlyForecast != nil,
+					dailySummary:      ctx.Modules.DerivedDailySummary != nil,
+					daypartSummaries:  ctx.Modules.DerivedDaypartSummaries != nil,
+					dayparts:          len(ctx.Modules.Dayparts),
+					precip:            ctx.Modules.PrecipTiming != nil,
+					alerts:            ctx.Modules.AlertDigest != nil,
+					outlooks:          ctx.Modules.SPCConvectiveOutlooks != nil,
+					discussion:        ctx.Modules.AreaForecastDiscussion != nil,
+					spcDiscussion:     ctx.Modules.SPCConvectiveDiscussion != nil,
+					story:             ctx.Modules.WeatherStory != nil,
+					planning:          ctx.Modules.TomorrowPlanning != nil,
+					collected:         ctx.Collected.FetchedAt.Equal(collected.FetchedAt),
+					derived:           len(ctx.Derived.DaypartSummaries) == len(derived.DaypartSummaries),
+				}
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result := test.build(t)
+			if result.title != test.wantTitle {
+				t.Fatalf("title = %q, want %q", result.title, test.wantTitle)
+			}
+			if result.forecastDateLabel != "Monday, June 15, 2026" {
+				t.Fatalf("forecastDateLabel = %q, want Monday, June 15, 2026", result.forecastDateLabel)
+			}
+			if result.generatedAtLabel != test.wantGeneratedLabel {
+				t.Fatalf("generatedAtLabel = %q, want %q", result.generatedAtLabel, test.wantGeneratedLabel)
+			}
+			if result.timezone != "America/Chicago" {
+				t.Fatalf("timezone = %q, want America/Chicago", result.timezone)
+			}
+			if !result.validPeriod.IsValid() {
+				t.Fatalf("validPeriod = %#v, want valid period", result.validPeriod)
+			}
+			if !result.metadata || !result.current || !result.hourly || !result.dailySummary || !result.daypartSummaries || !result.precip || !result.alerts || !result.outlooks || !result.discussion || !result.spcDiscussion || !result.story {
+				t.Fatalf("common modules = %#v, want all shared modules populated", result)
+			}
+			if result.dayparts != test.wantDayparts {
+				t.Fatalf("dayparts = %d, want %d", result.dayparts, test.wantDayparts)
+			}
+			if !result.planning {
+				t.Fatalf("planning = false, want %s planning module populated", test.name)
+			}
+			if !result.collected || !result.derived {
+				t.Fatalf("facts passthrough = collected:%t derived:%t, want both true", result.collected, result.derived)
+			}
+		})
+	}
+}
+
+func TestBuildDailyRenderContext(t *testing.T) {
+	metadata := testDailyMetadata()
+	snapshot := testDailySnapshot(t)
+	generated := Daily{
+		Summary: "The selected day starts quiet, then showers become more likely later in the day.",
+		ForecastDiscussion: []string{
+			"Morning conditions should stay mostly dry.",
+			"Rain chances increase during the afternoon as deeper moisture arrives.",
+		},
+		PrecipitationTiming: "The most likely rain window is from midafternoon into early evening.",
+	}
+	collected := testCollected()
+	derived := testDailyDerived()
+
+	ctx, err := BuildDailyRenderContext(metadata, snapshot, generated, collected, derived)
+	if err != nil {
+		t.Fatalf("BuildDailyRenderContext() error = %v", err)
+	}
+	if ctx.Report.Title != "Monday's Weather" {
+		t.Fatalf("Report.Title = %q, want Monday's Weather", ctx.Report.Title)
+	}
+	if ctx.Report.ForecastDateLabel != "Monday, June 15, 2026" || ctx.Report.ForecastDayName != "Monday" {
+		t.Fatalf("forecast date labels = %q/%q, want Monday labels", ctx.Report.ForecastDateLabel, ctx.Report.ForecastDayName)
+	}
+	if ctx.Report.GeneratedAtLabel != "Saturday, June 13, 2026 at 9:14 AM" {
+		t.Fatalf("Report.GeneratedAtLabel = %q, want friendly generated-at label", ctx.Report.GeneratedAtLabel)
+	}
+	if !ctx.Report.ValidPeriod.Start.Equal(metadata.ValidPeriod.Start) || !ctx.Report.ValidPeriod.End.Equal(metadata.ValidPeriod.End) || ctx.Report.Timezone != "America/Chicago" {
+		t.Fatalf("period/timezone = %#v/%q, want metadata passthrough", ctx.Report.ValidPeriod, ctx.Report.Timezone)
+	}
+	if ctx.Modules.Metadata == nil || ctx.Modules.Metadata.ReportID != report.Daily {
+		t.Fatalf("Modules.Metadata = %#v, want daily metadata", ctx.Modules.Metadata)
+	}
+	if ctx.Modules.CurrentConditions == nil || ctx.Modules.HourlyForecast == nil {
+		t.Fatalf("current/hourly modules = %#v/%#v, want available in render context", ctx.Modules.CurrentConditions, ctx.Modules.HourlyForecast)
+	}
+	if ctx.Modules.DerivedDailySummary == nil || ctx.Modules.DerivedDailySummary.HighTempF == nil || *ctx.Modules.DerivedDailySummary.HighTempF != 74 {
+		t.Fatalf("Modules.DerivedDailySummary = %#v, want daily summary", ctx.Modules.DerivedDailySummary)
+	}
+	if ctx.Modules.DerivedDaypartSummaries == nil || len(*ctx.Modules.DerivedDaypartSummaries) != 3 {
+		t.Fatalf("Modules.DerivedDaypartSummaries = %#v, want daypart map", ctx.Modules.DerivedDaypartSummaries)
+	}
+	if len(ctx.Modules.Dayparts) != 3 || ctx.Modules.Dayparts[0].Key != "morning" || ctx.Modules.Dayparts[1].Key != "afternoon" || ctx.Modules.Dayparts[2].Key != "evening" {
+		t.Fatalf("Modules.Dayparts = %#v, want derived order followed by remaining keys", ctx.Modules.Dayparts)
+	}
+	if morning := (*ctx.Modules.DerivedDaypartSummaries)["morning"]; morning.DominantConditionDisplay == "" || morning.DominantConditionLower == "" || morning.TemperatureSteadyPhraseF == "" {
+		t.Fatalf("daily rich morning daypart helpers = %#v, want render-context helper fields", morning)
+	}
+	if afternoon := (*ctx.Modules.DerivedDaypartSummaries)["afternoon"]; afternoon.MaxPopTimeLabel != "3:00 PM" {
+		t.Fatalf("daily rich afternoon daypart = %#v, want max pop time label helper", afternoon)
+	}
+	if ctx.Modules.PrecipTiming == nil || len(ctx.Modules.PrecipTiming.PrecipitationWindows) != 1 {
+		t.Fatalf("Modules.PrecipTiming = %#v, want precipitation window", ctx.Modules.PrecipTiming)
+	}
+	if ctx.Modules.AlertDigest == nil || ctx.Modules.SPCConvectiveOutlooks == nil || ctx.Modules.AreaForecastDiscussion == nil || ctx.Modules.SPCConvectiveDiscussion == nil || ctx.Modules.WeatherStory == nil || ctx.Modules.OutdoorWindows == nil || ctx.Modules.DailyPlanning == nil {
+		t.Fatalf("optional modules missing from render context: %#v", ctx.Modules)
+	}
+	if ctx.Modules.OutdoorWindows.Best == nil || ctx.Modules.OutdoorWindows.Best.Daypart != "morning" {
+		t.Fatalf("Modules.OutdoorWindows = %#v, want morning best window", ctx.Modules.OutdoorWindows)
+	}
+	if ctx.Modules.DailyPlanning.MorningReadiness[0] != "Take sunglasses early." {
+		t.Fatalf("Modules.DailyPlanning = %#v, want daily planning facts", ctx.Modules.DailyPlanning)
+	}
+	if !ctx.Collected.FetchedAt.Equal(collected.FetchedAt) {
+		t.Fatalf("Collected.FetchedAt = %s, want %s", ctx.Collected.FetchedAt, collected.FetchedAt)
+	}
+	if len(ctx.Derived.DaypartSummaries) != 2 {
+		t.Fatalf("Derived.DaypartSummaries = %#v, want passthrough facts", ctx.Derived.DaypartSummaries)
+	}
+
+	rendered, err := reporttemplate.Render("daily", ctx)
+	if err != nil {
+		t.Fatalf("Render() error = %v", err)
+	}
+	text := string(rendered)
+	for _, want := range []string{
+		"# Monday's Weather",
+		"**Forecast date:** Monday, June 15, 2026",
+		"**Updated:** Saturday, June 13, 2026 at 9:14 AM",
+		"The selected day starts quiet, then showers become more likely later in the day.",
+		"- **Morning:** Partly cloudy, with temperatures in the low 60s.",
+		"- **Afternoon:** Showers, with temperatures in the mid 70s. Chance of precipitation is 70%.",
+		"- **Evening:** Mostly cloudy, with temperatures in the upper 60s.",
+		"## Precipitation Timing",
+		"- **3:00 PM** to **6:00 PM**: Expect showers. The peak precipitation chance is 70% at 3:00 PM.",
+		"The most likely rain window is from midafternoon into early evening.",
+		"Morning conditions should stay mostly dry.",
+		"Rain chances increase during the afternoon as deeper moisture arrives.",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("rendered template missing %q:\n%s", want, text)
+		}
+	}
+	assertOrderedText(t, text, []string{
+		"# Monday's Weather",
+		"## Daypart Forecast",
+		"- **Morning:**",
+		"- **Afternoon:**",
+		"- **Evening:**",
+		"## Precipitation Timing",
+		"## Forecast Discussion",
+	})
+}
+
+func TestBuildDailyRenderContextAllowsOmittedOptionalModules(t *testing.T) {
+	snapshot, err := module.NewSnapshot(nil)
+	if err != nil {
+		t.Fatalf("NewSnapshot() error = %v", err)
+	}
+	ctx, err := BuildDailyRenderContext(testDailyMetadata(), snapshot, Daily{
+		Summary:            "Dry weather is expected for the selected day.",
+		ForecastDiscussion: []string{"High pressure keeps conditions quiet."},
+	}, testCollected(), facts.DerivedFacts{})
+	if err != nil {
+		t.Fatalf("BuildDailyRenderContext() error = %v", err)
+	}
+	if ctx.Modules.Metadata != nil || ctx.Modules.CurrentConditions != nil || ctx.Modules.PrecipTiming != nil || ctx.Modules.OutdoorWindows != nil || ctx.Modules.DailyPlanning != nil || len(ctx.Modules.Dayparts) != 0 {
+		t.Fatalf("Modules = %#v, want omitted optional modules", ctx.Modules)
+	}
+	rendered, err := reporttemplate.Render("daily", ctx)
+	if err != nil {
+		t.Fatalf("Render() error = %v", err)
+	}
+	text := string(rendered)
+	if strings.Contains(text, "## Precipitation Timing") {
+		t.Fatalf("rendered template included precipitation section without windows:\n%s", text)
+	}
+	if !strings.Contains(text, "- No daypart forecast details are available.") {
+		t.Fatalf("rendered template missing daypart fallback:\n%s", text)
 	}
 }
 
@@ -156,6 +632,12 @@ func TestBuildTomorrowRenderContext(t *testing.T) {
 	if len(ctx.Modules.Dayparts) != 2 || ctx.Modules.Dayparts[0].Key != "morning" || ctx.Modules.Dayparts[1].Key != "afternoon" {
 		t.Fatalf("Modules.Dayparts = %#v, want configured order", ctx.Modules.Dayparts)
 	}
+	if morning := (*ctx.Modules.DerivedDaypartSummaries)["morning"]; morning.DominantConditionDisplay == "" || morning.DominantConditionLower == "" || morning.TemperatureSteadyPhraseF == "" {
+		t.Fatalf("tomorrow rich morning daypart helpers = %#v, want render-context helper fields", morning)
+	}
+	if afternoon := (*ctx.Modules.DerivedDaypartSummaries)["afternoon"]; afternoon.MaxPopTimeLabel != "3:00 PM" {
+		t.Fatalf("tomorrow rich afternoon daypart = %#v, want max pop time label helper", afternoon)
+	}
 	if ctx.Modules.PrecipTiming == nil || len(ctx.Modules.PrecipTiming.PrecipitationWindows) != 1 {
 		t.Fatalf("Modules.PrecipTiming = %#v, want precipitation window", ctx.Modules.PrecipTiming)
 	}
@@ -181,7 +663,7 @@ func TestBuildTomorrowRenderContext(t *testing.T) {
 		"- **Morning:** Partly cloudy, with temperatures in the low 60s.",
 		"- **Afternoon:** Showers, with temperatures in the mid 70s. Chance of precipitation is 70%.",
 		"## Precipitation Timing",
-		"- **3:00 PM** to **6:00 PM**: Precipitation is expected during this period. The peak precipitation chance is 70% at 3:00 PM.",
+		"- **3:00 PM** to **6:00 PM**: Expect showers. The peak precipitation chance is 70% at 3:00 PM.",
 		"The most likely rain window is from midafternoon into early evening.",
 		"Morning conditions should stay mostly dry.",
 		"Rain chances increase during the afternoon as deeper moisture arrives.",
@@ -212,7 +694,7 @@ func TestBuildTomorrowRenderContextAllowsOmittedOptionalModules(t *testing.T) {
 	if err != nil {
 		t.Fatalf("BuildTomorrowRenderContext() error = %v", err)
 	}
-	if ctx.Modules.PrecipTiming != nil || len(ctx.Modules.Dayparts) != 0 {
+	if ctx.Modules.Metadata != nil || ctx.Modules.CurrentConditions != nil || ctx.Modules.PrecipTiming != nil || len(ctx.Modules.Dayparts) != 0 {
 		t.Fatalf("Modules = %#v, want omitted optional modules", ctx.Modules)
 	}
 	rendered, err := reporttemplate.Render("tomorrow", ctx)
@@ -268,6 +750,46 @@ func testTomorrowMetadata() briefing.Metadata {
 	}
 }
 
+func testDailyMetadata() briefing.Metadata {
+	generatedAt := time.Date(2026, 6, 13, 14, 14, 0, 0, time.UTC)
+	return briefing.Metadata{
+		RunID:       "run-daily",
+		ReportID:    report.Daily,
+		PromptID:    "weather.daily_generated_text",
+		GeneratedAt: generatedAt,
+		Units:       "imperial",
+		Timezone:    "America/Chicago",
+		ValidPeriod: timeutil.Period{
+			Start: time.Date(2026, 6, 15, 5, 0, 0, 0, time.UTC),
+			End:   time.Date(2026, 6, 16, 5, 0, 0, 0, time.UTC),
+		},
+		Location: &briefing.LocationContext{
+			Name:   "Brentwood",
+			Region: "MO",
+		},
+	}
+}
+
+func testTodayMetadata() briefing.Metadata {
+	generatedAt := time.Date(2026, 6, 15, 12, 14, 0, 0, time.UTC)
+	return briefing.Metadata{
+		RunID:       "run-today",
+		ReportID:    report.Today,
+		PromptID:    "weather.today_generated_text",
+		GeneratedAt: generatedAt,
+		Units:       "imperial",
+		Timezone:    "America/Chicago",
+		ValidPeriod: timeutil.Period{
+			Start: time.Date(2026, 6, 15, 5, 0, 0, 0, time.UTC),
+			End:   time.Date(2026, 6, 16, 5, 0, 0, 0, time.UTC),
+		},
+		Location: &briefing.LocationContext{
+			Name:   "Brentwood",
+			Region: "MO",
+		},
+	}
+}
+
 func testCollected() facts.CollectedFacts {
 	return facts.CollectedFacts{FetchedAt: time.Date(2026, 5, 29, 13, 31, 0, 0, time.UTC)}
 }
@@ -277,6 +799,18 @@ func testDerived() facts.DerivedFacts {
 }
 
 func testTomorrowDerived() facts.DerivedFacts {
+	return testCivilDayDerived()
+}
+
+func testDailyDerived() facts.DerivedFacts {
+	return testCivilDayDerived()
+}
+
+func testTodayDerived() facts.DerivedFacts {
+	return testCivilDayDerived()
+}
+
+func testCivilDayDerived() facts.DerivedFacts {
 	morningStart := time.Date(2026, 6, 15, 11, 0, 0, 0, time.UTC)
 	afternoonStart := time.Date(2026, 6, 15, 17, 0, 0, 0, time.UTC)
 	return facts.DerivedFacts{
@@ -299,6 +833,286 @@ func testTomorrowDerived() facts.DerivedFacts {
 	}
 }
 
+func testTodaySnapshot(t *testing.T) module.Snapshot {
+	t.Helper()
+	snapshot, err := module.NewSnapshot([]module.Output{
+		{
+			ID:         module.Metadata,
+			StanzaName: string(module.Metadata),
+			Value: briefing.MetadataModule{
+				RunID:       "run-today",
+				ReportID:    report.Today,
+				PromptID:    "weather.today_generated_text",
+				GeneratedAt: testTodayMetadata().GeneratedAt,
+				Units:       "imperial",
+				Timezone:    "America/Chicago",
+				ValidPeriod: testTodayMetadata().ValidPeriod,
+			},
+		},
+		{
+			ID:         module.CurrentConditions,
+			StanzaName: string(module.CurrentConditions),
+			Value: briefing.CurrentConditionsModule{
+				ConditionTextLower:      "clear",
+				TemperatureF:            intPtr(58),
+				ApparentTemperatureF:    intPtr(57),
+				RelativeHumidityPercent: intPtr(61),
+				WindSpeedMph:            intPtr(9),
+				WindDirectionText:       "northwest",
+			},
+		},
+		{
+			ID:         module.HourlyForecast,
+			StanzaName: string(module.HourlyForecast),
+			Value: briefing.HourlyForecastModule{
+				Periods: []briefing.HourlyForecastPeriod{
+					{HourLabel: "7:00 AM", TextDescriptionLower: "partly cloudy", TemperatureF: floatPtr(63)},
+				},
+			},
+		},
+		{
+			ID:         module.DerivedDailySummary,
+			StanzaName: string(module.DerivedDailySummary),
+			Value: briefing.DerivedDailySummaryModule{
+				Date:                          "Monday, June 15, 2026",
+				HighTempF:                     intPtr(74),
+				LowTempF:                      intPtr(61),
+				DailyPrecipitationProbability: intPtr(70),
+			},
+		},
+		{
+			ID:         module.DerivedDaypartSummaries,
+			StanzaName: string(module.DerivedDaypartSummaries),
+			Value: map[string]briefing.DerivedDaypartSummaryModule{
+				"afternoon": {
+					DisplayName:              "Afternoon",
+					TemperatureTrend:         "steady",
+					TemperatureSteadyPhraseF: "mid 70s",
+					DominantConditionDisplay: "Showers",
+					DominantConditionLower:   "showers",
+					MaxPopPercent:            intPtr(70),
+					MaxPopTimeLabel:          "3:00 PM",
+					MentionPrecipitation:     true,
+				},
+				"morning": {
+					DisplayName:              "Morning",
+					TemperatureTrend:         "steady",
+					TemperatureSteadyPhraseF: "low 60s",
+					DominantConditionDisplay: "Partly cloudy",
+					DominantConditionLower:   "partly cloudy",
+				},
+			},
+		},
+		{
+			ID:         module.PrecipTiming,
+			StanzaName: string(module.PrecipTiming),
+			Value: briefing.PrecipTimingModule{
+				MaxPopPercent: intPtr(70),
+				MaxPopTime:    "3 PM",
+				PrecipitationWindows: []briefing.PrecipitationWindowModule{
+					{PeriodBeginsHourLabel: "3:00 PM", PeriodEndsHourLabel: "6:00 PM", MaxPopPercent: intPtr(70), MaxPopHourLabel: "3:00 PM", PrecipitationType: "showers", ExpectationPhrase: "Expect showers."},
+				},
+			},
+		},
+		{
+			ID:         module.AlertDigest,
+			StanzaName: string(module.AlertDigest),
+			Value: briefing.AlertDigestModule{
+				Checked: true,
+			},
+		},
+		{
+			ID:         module.SPCConvectiveOutlooks,
+			StanzaName: string(module.SPCConvectiveOutlooks),
+			Value: briefing.SPCConvectiveOutlooksModule{
+				Checked: true,
+			},
+		},
+		{
+			ID:         module.AreaForecastDiscussion,
+			StanzaName: string(module.AreaForecastDiscussion),
+			Value: briefing.AreaForecastDiscussionModule{
+				KeyMessages: []string{"Rain chances increase late."},
+			},
+		},
+		{
+			ID:         module.SPCConvectiveDiscussion,
+			StanzaName: string(module.SPCConvectiveDiscussion),
+			Value: briefing.SPCConvectiveDiscussionModule{
+				IncludedBecause: "convective outlook",
+			},
+		},
+		{
+			ID:         module.WeatherStory,
+			StanzaName: string(module.WeatherStory),
+			Value: briefing.WeatherStoryModule{
+				Available: true,
+				Title:     "Rain returns",
+			},
+		},
+		{
+			ID:         module.TodayPlanning,
+			StanzaName: string(module.TodayPlanning),
+			Value: briefing.TodayPlanningModule{
+				MorningReadiness: []string{"Take sunglasses early."},
+				OutdoorPlanning:  []string{"Best outdoor window: Morning (quiet weather)."},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewSnapshot() error = %v", err)
+	}
+	return snapshot
+}
+
+func testDailySnapshot(t *testing.T) module.Snapshot {
+	t.Helper()
+	snapshot, err := module.NewSnapshot([]module.Output{
+		{
+			ID:         module.Metadata,
+			StanzaName: string(module.Metadata),
+			Value: briefing.MetadataModule{
+				RunID:       "run-daily",
+				ReportID:    report.Daily,
+				PromptID:    "weather.daily_generated_text",
+				GeneratedAt: testDailyMetadata().GeneratedAt,
+				Units:       "imperial",
+				Timezone:    "America/Chicago",
+				ValidPeriod: testDailyMetadata().ValidPeriod,
+			},
+		},
+		{
+			ID:         module.CurrentConditions,
+			StanzaName: string(module.CurrentConditions),
+			Value: briefing.CurrentConditionsModule{
+				ConditionTextLower: "clear",
+				TemperatureF:       intPtr(58),
+			},
+		},
+		{
+			ID:         module.HourlyForecast,
+			StanzaName: string(module.HourlyForecast),
+			Value: briefing.HourlyForecastModule{
+				Periods: []briefing.HourlyForecastPeriod{
+					{HourLabel: "7:00 AM", TextDescriptionLower: "partly cloudy", TemperatureF: floatPtr(63)},
+				},
+			},
+		},
+		{
+			ID:         module.DerivedDailySummary,
+			StanzaName: string(module.DerivedDailySummary),
+			Value: briefing.DerivedDailySummaryModule{
+				Date:                          "Monday, June 15, 2026",
+				HighTempF:                     intPtr(74),
+				LowTempF:                      intPtr(61),
+				DailyPrecipitationProbability: intPtr(70),
+			},
+		},
+		{
+			ID:         module.DerivedDaypartSummaries,
+			StanzaName: string(module.DerivedDaypartSummaries),
+			Value: map[string]briefing.DerivedDaypartSummaryModule{
+				"afternoon": {
+					DisplayName:              "Afternoon",
+					TemperatureTrend:         "steady",
+					TemperatureSteadyPhraseF: "mid 70s",
+					DominantConditionDisplay: "Showers",
+					DominantConditionLower:   "showers",
+					MaxPopPercent:            intPtr(70),
+					MaxPopTimeLabel:          "3:00 PM",
+					MentionPrecipitation:     true,
+				},
+				"evening": {
+					DisplayName:              "Evening",
+					TemperatureTrend:         "steady",
+					TemperatureSteadyPhraseF: "upper 60s",
+					DominantConditionDisplay: "Mostly cloudy",
+					DominantConditionLower:   "mostly cloudy",
+				},
+				"morning": {
+					DisplayName:              "Morning",
+					TemperatureTrend:         "steady",
+					TemperatureSteadyPhraseF: "low 60s",
+					DominantConditionDisplay: "Partly cloudy",
+					DominantConditionLower:   "partly cloudy",
+				},
+			},
+		},
+		{
+			ID:         module.PrecipTiming,
+			StanzaName: string(module.PrecipTiming),
+			Value: briefing.PrecipTimingModule{
+				MaxPopPercent: intPtr(70),
+				MaxPopTime:    "3 PM",
+				PrecipitationWindows: []briefing.PrecipitationWindowModule{
+					{PeriodBeginsHourLabel: "3:00 PM", PeriodEndsHourLabel: "6:00 PM", MaxPopPercent: intPtr(70), MaxPopHourLabel: "3:00 PM", PrecipitationType: "showers", ExpectationPhrase: "Expect showers."},
+				},
+			},
+		},
+		{
+			ID:         module.AlertDigest,
+			StanzaName: string(module.AlertDigest),
+			Value: briefing.AlertDigestModule{
+				Checked: true,
+			},
+		},
+		{
+			ID:         module.SPCConvectiveOutlooks,
+			StanzaName: string(module.SPCConvectiveOutlooks),
+			Value: briefing.SPCConvectiveOutlooksModule{
+				Checked: true,
+			},
+		},
+		{
+			ID:         module.AreaForecastDiscussion,
+			StanzaName: string(module.AreaForecastDiscussion),
+			Value: briefing.AreaForecastDiscussionModule{
+				KeyMessages: []string{"Rain chances increase late."},
+			},
+		},
+		{
+			ID:         module.SPCConvectiveDiscussion,
+			StanzaName: string(module.SPCConvectiveDiscussion),
+			Value: briefing.SPCConvectiveDiscussionModule{
+				IncludedBecause: "convective outlook",
+			},
+		},
+		{
+			ID:         module.WeatherStory,
+			StanzaName: string(module.WeatherStory),
+			Value: briefing.WeatherStoryModule{
+				Available: true,
+				Title:     "Rain returns",
+			},
+		},
+		{
+			ID:         module.OutdoorWindows,
+			StanzaName: string(module.OutdoorWindows),
+			Value: briefing.OutdoorWindowsModule{
+				Best: &briefing.OutdoorWindowModule{
+					Daypart: "morning",
+					Reasons: []string{"quiet weather"},
+				},
+				Worst: &briefing.OutdoorWindowModule{
+					Daypart: "afternoon",
+					Reasons: []string{"high precipitation chance"},
+				},
+			},
+		},
+		{
+			ID:         module.DailyPlanning,
+			StanzaName: string(module.DailyPlanning),
+			Value: briefing.DailyPlanningModule{
+				MorningReadiness: []string{"Take sunglasses early."},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewSnapshot() error = %v", err)
+	}
+	return snapshot
+}
+
 func testSnapshot(t *testing.T) module.Snapshot {
 	t.Helper()
 	snapshot, err := module.NewSnapshot([]module.Output{
@@ -376,7 +1190,7 @@ func testSnapshot(t *testing.T) module.Snapshot {
 				ActiveCount:   1,
 				RelevantCount: 1,
 				Relevant: []briefing.AlertSummary{
-					{Event: "Flood Watch", Headline: "Flood Watch until early afternoon", Severity: "Moderate"},
+					{Event: "Flood Watch", Headline: "Flood Watch until early afternoon", Severity: "Moderate", PeriodBegins: "May 29 at 10:00 AM", PeriodEnds: "May 29 at 2:30 PM", Instruction: "Avoid low-water crossings."},
 				},
 			},
 		},
@@ -503,7 +1317,7 @@ func testTomorrowSnapshot(t *testing.T) module.Snapshot {
 				MaxPopPercent: intPtr(70),
 				MaxPopTime:    "3 PM",
 				PrecipitationWindows: []briefing.PrecipitationWindowModule{
-					{PeriodBeginsHourLabel: "3:00 PM", PeriodEndsHourLabel: "6:00 PM", MaxPopPercent: intPtr(70), MaxPopHourLabel: "3:00 PM"},
+					{PeriodBeginsHourLabel: "3:00 PM", PeriodEndsHourLabel: "6:00 PM", MaxPopPercent: intPtr(70), MaxPopHourLabel: "3:00 PM", PrecipitationType: "showers", ExpectationPhrase: "Expect showers."},
 				},
 			},
 		},

internal/generatedtext/today.go

@@ -0,0 +1,28 @@
+package generatedtext
+
+type Today struct {
+	Summary             string   `json:"summary"`
+	ForecastDiscussion  []string `json:"forecast_discussion"`
+	PrecipitationTiming string   `json:"precipitation_timing,omitempty"`
+	Confidence          string   `json:"confidence,omitempty"`
+}
+
+func ValidateToday(data []byte) (Today, []byte, error) {
+	return validateDayStyleGeneratedText[Today, *Today](data, "today")
+}
+
+func (t *Today) dayStyleFields() dayStyleFields {
+	return dayStyleFields{
+		Summary:             t.Summary,
+		ForecastDiscussion:  t.ForecastDiscussion,
+		PrecipitationTiming: t.PrecipitationTiming,
+		Confidence:          t.Confidence,
+	}
+}
+
+func (t *Today) setDayStyleFields(fields dayStyleFields) {
+	t.Summary = fields.Summary
+	t.ForecastDiscussion = fields.ForecastDiscussion
+	t.PrecipitationTiming = fields.PrecipitationTiming
+	t.Confidence = fields.Confidence
+}

internal/generatedtext/today_test.go

@@ -0,0 +1,111 @@
+package generatedtext
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateTodayNormalizesJSON(t *testing.T) {
+	value, normalized, err := ValidateToday([]byte(`{
+		"summary": " Showers are likely today. ",
+		"forecast_discussion": [
+			"  A front will keep rain chances elevated. ",
+			"",
+			"  Temperatures stay mild through the afternoon. "
+		],
+		"precipitation_timing": " Rain is most likely during the afternoon. ",
+		"confidence": " Medium "
+	}`))
+	if err != nil {
+		t.Fatalf("ValidateToday() error = %v", err)
+	}
+	if value.Summary != "Showers are likely today." {
+		t.Fatalf("Summary = %q, want trimmed summary", value.Summary)
+	}
+	if strings.Join(value.ForecastDiscussion, "|") != "A front will keep rain chances elevated.|Temperatures stay mild through the afternoon." {
+		t.Fatalf("ForecastDiscussion = %#v, want trimmed non-empty paragraphs", value.ForecastDiscussion)
+	}
+	if value.PrecipitationTiming != "Rain is most likely during the afternoon." {
+		t.Fatalf("PrecipitationTiming = %q, want trimmed precipitation timing", value.PrecipitationTiming)
+	}
+	want := `{"summary":"Showers are likely today.","forecast_discussion":["A front will keep rain chances elevated.","Temperatures stay mild through the afternoon."],"precipitation_timing":"Rain is most likely during the afternoon.","confidence":"Medium"}`
+	if string(normalized) != want {
+		t.Fatalf("normalized = %s, want %s", normalized, want)
+	}
+}
+
+func TestValidateTodayOmitsEmptyOptionalFields(t *testing.T) {
+	_, normalized, err := ValidateToday([]byte(`{
+		"summary": "Showers are likely today.",
+		"forecast_discussion": ["A front will keep rain chances elevated."],
+		"precipitation_timing": "   ",
+		"confidence": "   "
+	}`))
+	if err != nil {
+		t.Fatalf("ValidateToday() error = %v", err)
+	}
+	want := `{"summary":"Showers are likely today.","forecast_discussion":["A front will keep rain chances elevated."]}`
+	if string(normalized) != want {
+		t.Fatalf("normalized = %s, want %s", normalized, want)
+	}
+}
+
+func TestValidateTodayRejectsInvalidInput(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "malformed",
+			in:   `{`,
+			want: "decode today generated text",
+		},
+		{
+			name: "unknown field",
+			in:   `{"summary":"Showers are likely today.","forecast_discussion":["A front will keep rain chances elevated."],"extra":"value"}`,
+			want: `unknown field "extra"`,
+		},
+		{
+			name: "missing summary",
+			in:   `{"forecast_discussion":["A front will keep rain chances elevated."]}`,
+			want: "summary is required",
+		},
+		{
+			name: "blank summary",
+			in:   `{"summary":"  ","forecast_discussion":["A front will keep rain chances elevated."]}`,
+			want: "summary is required",
+		},
+		{
+			name: "missing forecast discussion",
+			in:   `{"summary":"Showers are likely today."}`,
+			want: "forecast discussion is required",
+		},
+		{
+			name: "blank forecast discussion",
+			in:   `{"summary":"Showers are likely today.","forecast_discussion":["  ",""]}`,
+			want: "forecast discussion is required",
+		},
+		{
+			name: "forecast discussion wrong type",
+			in:   `{"summary":"Showers are likely today.","forecast_discussion":"A front will keep rain chances elevated."}`,
+			want: "cannot unmarshal string",
+		},
+		{
+			name: "multiple values",
+			in:   `{"summary":"Showers are likely today.","forecast_discussion":["A front will keep rain chances elevated."]} {}`,
+			want: "multiple JSON values",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, err := ValidateToday([]byte(test.in))
+			if err == nil {
+				t.Fatal("ValidateToday() error = nil, want error")
+			}
+			if !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("ValidateToday() error = %v, want %q", err, test.want)
+			}
+		})
+	}
+}

internal/generatedtext/tomorrow.go

@@ -1,13 +1,5 @@
 package generatedtext
 
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"strings"
-)
-
 type Tomorrow struct {
 	Summary             string   `json:"summary"`
 	ForecastDiscussion  []string `json:"forecast_discussion"`
@@ -16,47 +8,21 @@ type Tomorrow struct {
 }
 
 func ValidateTomorrow(data []byte) (Tomorrow, []byte, error) {
-	decoder := json.NewDecoder(bytes.NewReader(data))
-	decoder.DisallowUnknownFields()
-
-	var value Tomorrow
-	if err := decoder.Decode(&value); err != nil {
-		return Tomorrow{}, nil, fmt.Errorf("decode tomorrow generated text: %w", err)
-	}
-	var extra any
-	if err := decoder.Decode(&extra); err != nil {
-		if err != io.EOF {
-			return Tomorrow{}, nil, fmt.Errorf("decode tomorrow generated text: %w", err)
-		}
-	} else {
-		return Tomorrow{}, nil, fmt.Errorf("decode tomorrow generated text: multiple JSON values")
-	}
-
-	value.Summary = strings.TrimSpace(value.Summary)
-	value.PrecipitationTiming = strings.TrimSpace(value.PrecipitationTiming)
-	value.Confidence = strings.TrimSpace(value.Confidence)
-	value.ForecastDiscussion = trimNonEmpty(value.ForecastDiscussion)
-	if value.Summary == "" {
-		return Tomorrow{}, nil, fmt.Errorf("tomorrow generated text summary is required")
-	}
-	if len(value.ForecastDiscussion) == 0 {
-		return Tomorrow{}, nil, fmt.Errorf("tomorrow generated text forecast discussion is required")
-	}
-
-	normalized, err := json.Marshal(value)
-	if err != nil {
-		return Tomorrow{}, nil, fmt.Errorf("normalize tomorrow generated text: %w", err)
-	}
-	return value, normalized, nil
+	return validateDayStyleGeneratedText[Tomorrow, *Tomorrow](data, "tomorrow")
 }
 
-func trimNonEmpty(values []string) []string {
-	out := make([]string, 0, len(values))
-	for _, value := range values {
-		trimmed := strings.TrimSpace(value)
-		if trimmed != "" {
-			out = append(out, trimmed)
+func (t *Tomorrow) dayStyleFields() dayStyleFields {
+	return dayStyleFields{
+		Summary:             t.Summary,
+		ForecastDiscussion:  t.ForecastDiscussion,
+		PrecipitationTiming: t.PrecipitationTiming,
+		Confidence:          t.Confidence,
 	}
-	}
-	return out
+}
+
+func (t *Tomorrow) setDayStyleFields(fields dayStyleFields) {
+	t.Summary = fields.Summary
+	t.ForecastDiscussion = fields.ForecastDiscussion
+	t.PrecipitationTiming = fields.PrecipitationTiming
+	t.Confidence = fields.Confidence
 }

internal/module/module.go

@@ -24,7 +24,9 @@ const (
 	SPCConvectiveOutlooks   ID = "spc_convective_outlooks"
 	SPCConvectiveDiscussion ID = "spc_convective_discussion"
 	OutdoorWindows          ID = "outdoor_windows"
+	TodayPlanning           ID = "today_planning"
 	TomorrowPlanning        ID = "tomorrow_planning"
+	DailyPlanning           ID = "daily_planning"
 )
 
 type ConfigItem struct {
@@ -36,6 +38,7 @@ type Output struct {
 	ID          ID     `json:"id"`
 	StanzaName  string `json:"stanzaName"`
 	Value       any    `json:"value"`
+	PromptValue any    `json:"-" yaml:"-"`
 }
 
 type Snapshot struct {
@@ -43,6 +46,13 @@ type Snapshot struct {
 	Outputs       []Output `json:"outputs"`
 }
 
+func (o Output) DataPackageValue() any {
+	if o.PromptValue != nil {
+		return o.PromptValue
+	}
+	return o.Value
+}
+
 func NewSnapshot(outputs []Output) (Snapshot, error) {
 	snapshot := Snapshot{
 		SchemaVersion: SnapshotSchemaVersion,
@@ -148,4 +158,6 @@ type WeatherStoryOptions struct{}
 type SPCConvectiveOutlooksOptions struct{}
 type SPCConvectiveDiscussionOptions struct{}
 type OutdoorWindowsOptions struct{}
+type TodayPlanningOptions struct{}
 type TomorrowPlanningOptions struct{}
+type DailyPlanningOptions struct{}

internal/module/module_test.go

@@ -13,7 +13,12 @@ type testStanza struct {
 
 func TestSnapshotPreservesOutputOrderAndJSON(t *testing.T) {
 	snapshot, err := NewSnapshot([]Output{
-		{ID: Metadata, StanzaName: "metadata", Value: testStanza{Message: "first", Count: 1}},
+		{
+			ID:          Metadata,
+			StanzaName:  "metadata",
+			Value:       testStanza{Message: "first", Count: 1},
+			PromptValue: testStanza{Message: "prompt-only", Count: 10},
+		},
 		{ID: AlertDigest, StanzaName: "alert_digest", Value: testStanza{Message: "second", Count: 2}},
 	})
 	if err != nil {
@@ -35,6 +40,26 @@ func TestSnapshotPreservesOutputOrderAndJSON(t *testing.T) {
 	if got != want {
 		t.Fatalf("json = %s, want %s", got, want)
 	}
+	if strings.Contains(got, "PromptValue") || strings.Contains(got, "promptValue") || strings.Contains(got, "prompt-only") {
+		t.Fatalf("json includes runtime-only prompt value: %s", got)
+	}
+}
+
+func TestOutputDataPackageValue(t *testing.T) {
+	output := Output{
+		ID:          Metadata,
+		StanzaName:  "metadata",
+		Value:       testStanza{Message: "rich", Count: 1},
+		PromptValue: testStanza{Message: "prompt", Count: 2},
+	}
+	if got := output.DataPackageValue(); got != output.PromptValue {
+		t.Fatalf("DataPackageValue() = %#v, want prompt value", got)
+	}
+
+	output.PromptValue = nil
+	if got := output.DataPackageValue(); got != output.Value {
+		t.Fatalf("DataPackageValue() = %#v, want rich value fallback", got)
+	}
 }
 
 func TestSnapshotRejectsDuplicateOutputs(t *testing.T) {
@@ -57,7 +82,12 @@ func TestSnapshotRejectsDuplicateOutputs(t *testing.T) {
 
 func TestStanzaValueDecodesTypedOutput(t *testing.T) {
 	snapshot, err := NewSnapshot([]Output{
-		{ID: Metadata, StanzaName: "metadata", Value: testStanza{Message: "available", Count: 3}},
+		{
+			ID:          Metadata,
+			StanzaName:  "metadata",
+			Value:       testStanza{Message: "available", Count: 3},
+			PromptValue: testStanza{Message: "prompt-only", Count: 99},
+		},
 	})
 	if err != nil {
 		t.Fatalf("NewSnapshot() error = %v", err)
@@ -100,3 +130,11 @@ func TestSPCConvectiveModuleContractsAreStable(t *testing.T) {
 	_ = SPCConvectiveOutlooksOptions{}
 	_ = SPCConvectiveDiscussionOptions{}
 }
+
+func TestDailyPlanningModuleContractIsStable(t *testing.T) {
+	if DailyPlanning != ID("daily_planning") {
+		t.Fatalf("DailyPlanning = %q, want stable module ID", DailyPlanning)
+	}
+
+	_ = DailyPlanningOptions{}
+}

internal/promptinput/package.go

@@ -16,7 +16,7 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-const SchemaVersion = "weatherreporter.data_package.v2"
+const SchemaVersion = "weatherreporter.data_package.v3"
 
 const (
 	metadataStanza                 = "metadata"
@@ -40,6 +40,8 @@ var briefingStanzaCategories = map[string]string{
 	string(module.DerivedDaypartSummaries): categoryDerivedSummaries,
 	string(module.PrecipTiming):            categoryDerivedSummaries,
 	string(module.OutdoorWindows):          categoryDerivedSummaries,
+	string(module.DailyPlanning):           categoryDerivedSummaries,
+	string(module.TodayPlanning):           categoryDerivedSummaries,
 	string(module.TomorrowPlanning):        categoryDerivedSummaries,
 	string(module.NarrativeForecast):       categoryNarrativeProducts,
 	string(module.AreaForecastDiscussion):  categoryNarrativeProducts,
@@ -131,7 +133,7 @@ func stanzasFromSnapshot(snapshot module.Snapshot) BriefingStanzas {
 	order := make([]string, 0, len(snapshot.Outputs))
 	for _, output := range snapshot.Outputs {
 		order = append(order, output.StanzaName)
-		values[output.StanzaName] = output.Value
+		values[output.StanzaName] = output.DataPackageValue()
 	}
 	return BriefingStanzas{Order: order, Values: values}
 }

internal/promptinput/package_test.go

@@ -19,11 +19,11 @@ func TestBuildDailyDataPackage(t *testing.T) {
 	if pkg.SchemaVersion != SchemaVersion {
 		t.Fatalf("SchemaVersion = %q, want %q", pkg.SchemaVersion, SchemaVersion)
 	}
-	if pkg.RunID != "20260529T100000Z_daily_today" {
+	if pkg.RunID != "20260529T100000Z_daily" {
 		t.Fatalf("RunID = %q, want metadata run id", pkg.RunID)
 	}
-	if pkg.Report.PromptID != "weather.daily_report" {
-		t.Fatalf("PromptID = %q, want weather.daily_report", pkg.Report.PromptID)
+	if pkg.Report.PromptID != "weather.daily_generated_text" {
+		t.Fatalf("PromptID = %q, want weather.daily_generated_text", pkg.Report.PromptID)
 	}
 	if pkg.Report.CurrentLocalDate != "2026-05-29" {
 		t.Fatalf("CurrentLocalDate = %q, want 2026-05-29", pkg.Report.CurrentLocalDate)
@@ -107,6 +107,7 @@ func TestBuildUsesNamedSnapshotStanzas(t *testing.T) {
 	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: "derived_daypart_summaries", Value: map[string]any{"days": []string{"2026-05-29"}}},
+		module.Output{ID: module.TodayPlanning, StanzaName: "today_planning", Value: map[string]any{"morning_readiness": []string{"routine"}}},
 	)
 
 	pkg, err := Build(req)
@@ -120,6 +121,47 @@ func TestBuildUsesNamedSnapshotStanzas(t *testing.T) {
 	if _, ok := pkg.Briefing.Values["derived_daypart_summaries"]; !ok {
 		t.Fatal("Briefing.Values[derived_daypart_summaries] missing")
 	}
+	if _, ok := pkg.Briefing.Values["today_planning"]; !ok {
+		t.Fatal("Briefing.Values[today_planning] missing")
+	}
+}
+
+func TestBuildUsesPromptValuesFromSnapshot(t *testing.T) {
+	req := validBuildRequest(t)
+	req.Modules = snapshotWithOutputs(t,
+		module.Output{
+			ID:          module.Metadata,
+			StanzaName:  "metadata",
+			Value:       map[string]string{"run_id": "rich"},
+			PromptValue: map[string]string{"run_id": "prompt"},
+		},
+		module.Output{
+			ID:          module.CurrentConditions,
+			StanzaName:  "current_conditions",
+			Value:       map[string]string{"condition_text": "Rich conditions"},
+			PromptValue: map[string]string{"condition_text": "Prompt conditions"},
+		},
+		module.Output{
+			ID:         module.AlertDigest,
+			StanzaName: "alert_digest",
+			Value:      map[string]bool{"checked": true},
+		},
+	)
+
+	pkg, err := Build(req)
+	if err != nil {
+		t.Fatalf("Build() error = %v", err)
+	}
+
+	if got := pkg.Briefing.Values["metadata"].(map[string]string)["run_id"]; got != "prompt" {
+		t.Fatalf("metadata.run_id = %q, want prompt value", got)
+	}
+	if got := pkg.Briefing.Values["current_conditions"].(map[string]string)["condition_text"]; got != "Prompt conditions" {
+		t.Fatalf("current_conditions.condition_text = %q, want prompt value", got)
+	}
+	if got := pkg.Briefing.Values["alert_digest"].(map[string]bool)["checked"]; !got {
+		t.Fatalf("alert_digest.checked = %v, want rich value fallback", got)
+	}
 }
 
 func TestMarshalYAMLIsDeterministicAndGroupsNamedStanzas(t *testing.T) {
@@ -139,7 +181,7 @@ func TestMarshalYAMLIsDeterministicAndGroupsNamedStanzas(t *testing.T) {
 	if string(first) != string(second) {
 		t.Fatalf("YAML output changed between marshals:\n%s\n---\n%s", string(first), string(second))
 	}
-	if !strings.Contains(string(first), "schema_version: weatherreporter.data_package.v2") ||
+	if !strings.Contains(string(first), "schema_version: weatherreporter.data_package.v3") ||
 		!strings.Contains(string(first), "briefing:\n") ||
 		!strings.Contains(string(first), "  applicable_risk_products:\n") ||
 		!strings.Contains(string(first), "  derived_summaries:\n") ||
@@ -247,11 +289,11 @@ func TestMarshalYAMLRejectsUncategorizedStanza(t *testing.T) {
 
 func TestLoadYAMLRejectsMisplacedStanza(t *testing.T) {
 	data := []byte(`
-schema_version: weatherreporter.data_package.v2
-run_id: 20260529T100000Z_daily_today
+schema_version: weatherreporter.data_package.v3
+run_id: 20260529T100000Z_daily
 report:
-  id: daily_today
-  prompt_id: weather.daily_report
+  id: daily
+  prompt_id: weather.daily_generated_text
   generated_at: 2026-05-29T10:00:00Z
   timezone: America/Chicago
   current_local_date: "2026-05-29"
@@ -260,7 +302,7 @@ report:
     end: 2026-05-30T05:00:00Z
 briefing:
   metadata:
-    run_id: 20260529T100000Z_daily_today
+    run_id: 20260529T100000Z_daily
   raw_data:
     alert_digest:
       checked: true
@@ -274,15 +316,32 @@ recent_changes:
 	}
 }
 
+func TestLoadYAMLRejectsOldSchemaVersion(t *testing.T) {
+	pkg, err := Build(validBuildRequest(t))
+	if err != nil {
+		t.Fatalf("Build() error = %v", err)
+	}
+	data, err := MarshalYAML(pkg)
+	if err != nil {
+		t.Fatalf("MarshalYAML() error = %v", err)
+	}
+	data = []byte(strings.Replace(string(data), "weatherreporter.data_package.v3", "weatherreporter.data_package.v2", 1))
+
+	_, err = LoadYAML(data)
+	if err == nil || !strings.Contains(err.Error(), "schemaVersion must be weatherreporter.data_package.v3") {
+		t.Fatalf("LoadYAML() error = %v, want current schema version error", err)
+	}
+}
+
 func validBuildRequest(t *testing.T) BuildRequest {
 	t.Helper()
 	generatedAt := time.Date(2026, 5, 29, 10, 0, 0, 0, time.UTC)
 	return BuildRequest{
 		Metadata: Metadata{
-			RunID:       "20260529T100000Z_daily_today",
-			ReportID:    report.DailyToday,
+			RunID:       "20260529T100000Z_daily",
+			ReportID:    report.Daily,
 			Variant:     "today",
-			PromptID:    "weather.daily_report",
+			PromptID:    "weather.daily_generated_text",
 			GeneratedAt: generatedAt,
 			Timezone:    "America/Chicago",
 			ValidPeriod: timeutil.Period{
@@ -291,7 +350,7 @@ func validBuildRequest(t *testing.T) BuildRequest {
 			},
 		},
 		Modules: snapshotWithOutputs(t,
-			module.Output{ID: module.Metadata, StanzaName: "metadata", Value: map[string]string{"run_id": "20260529T100000Z_daily_today"}},
+			module.Output{ID: module.Metadata, StanzaName: "metadata", Value: map[string]string{"run_id": "20260529T100000Z_daily"}},
 			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}},

internal/report/daily_report.go

@@ -1,48 +1,37 @@
 package report
 
 import (
+	"fmt"
+
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 )
 
-func dailyTodayDefinition() Definition {
+func dailyDefinition() Definition {
 	return Definition{
-		ID:                 DailyToday,
+		ID:                    Daily,
 		Name:                  "Daily Report",
-		PromptID:           "weather.daily_report",
-		GenerationMode:     GenerationModeScriptoriumMarkdown,
+		PromptID:              "weather.daily_generated_text",
+		GenerationMode:        GenerationModeGeneratedTextTemplate,
+		TemplateID:            "daily",
+		GeneratedTextSchemaID: "daily",
 		ComparisonStrategy:    CompareSameValidDate,
 		ArtifactGroup:         "daily",
 		BatchOutputName:       "daily.md",
+		DistributorPathTemplates: []string{
+			"daily/{valid_start_date}/{run_id}.md",
+			"daily/{valid_start_date}/index.md",
+		},
 		Generated:          true,
-		CompatiblePriorIDs: []ID{DailyToday},
-		Modules:            dailyTodayModules(),
-		Morning:            true,
-		resolve:            resolveDailyToday,
+		CompatiblePriorIDs: []ID{Daily},
+		Modules:            dailyModules(),
+		resolve:            resolveDaily,
+		runIDDisambiguator: validStartDateRunIDDisambiguator,
 	}
 }
 
-func tomorrowDefinition() Definition {
-	return Definition{
-		ID:                    Tomorrow,
-		Name:                  "Tomorrow Report",
-		PromptID:              "weather.tomorrow_generated_text",
-		GenerationMode:        GenerationModeGeneratedTextTemplate,
-		TemplateID:            "tomorrow",
-		GeneratedTextSchemaID: "tomorrow",
-		ComparisonStrategy:    CompareSameValidDate,
-		ArtifactGroup:         "tomorrow",
-		BatchOutputName:       "tomorrow.md",
-		Generated:             true,
-		CompatiblePriorIDs:    []ID{Tomorrow},
-		Modules:               tomorrowModules(),
-		Evening:               true,
-		resolve:               resolveTomorrow,
-	}
-}
-
-func dailyTodayModules() []module.ConfigItem {
-	return moduleItems(
+func dailyModules() []module.ConfigItem {
+	items := moduleItems(
 		module.Metadata,
 		module.CurrentConditions,
 		module.NarrativeForecast,
@@ -51,40 +40,32 @@ func dailyTodayModules() []module.ConfigItem {
 		module.PrecipTiming,
 		module.AlertDigest,
 		module.SPCConvectiveOutlooks,
-		module.AreaForecastDiscussion,
+	)
+	items = append(items, areaForecastDiscussionItem("long_term"))
+	items = append(items, moduleItems(
 		module.SPCConvectiveDiscussion,
 		module.WeatherStory,
 		module.OutdoorWindows,
+		module.DailyPlanning,
 		module.HourlyForecast,
-	)
+	)...)
+	return items
 }
 
-func tomorrowModules() []module.ConfigItem {
-	return moduleItems(
-		module.Metadata,
-		module.CurrentConditions,
-		module.NarrativeForecast,
-		module.DerivedDailySummary,
-		module.DerivedDaypartSummaries,
-		module.PrecipTiming,
-		module.AlertDigest,
-		module.SPCConvectiveOutlooks,
-		module.AreaForecastDiscussion,
-		module.SPCConvectiveDiscussion,
-		module.WeatherStory,
-		module.OutdoorWindows,
-		module.TomorrowPlanning,
-		module.HourlyForecast,
-	)
-}
-
-func resolveDailyToday(req ResolveRequest) (timeutil.Period, error) {
-	if !req.Date.IsZero() {
+func resolveDaily(req ResolveRequest) (timeutil.Period, error) {
+	if req.Date.IsZero() {
+		return timeutil.Period{}, fmt.Errorf("daily report requires an explicit date")
+	}
 	return timeutil.CivilDay(req.Date, req.Location), nil
-	}
-	return timeutil.CivilDay(req.Now, req.Location), nil
 }
 
-func resolveTomorrow(req ResolveRequest) (timeutil.Period, error) {
-	return timeutil.CivilDay(req.Now.In(req.Location).AddDate(0, 0, 1), req.Location), nil
+func validStartDateRunIDDisambiguator(resolved Resolved) string {
+	if resolved.ValidPeriod.Start.IsZero() {
+		return ""
+	}
+	location, err := timeutil.LoadLocation(resolved.Timezone)
+	if err != nil {
+		return resolved.ValidPeriod.Start.Format(timeutil.DateLayout)
+	}
+	return resolved.ValidPeriod.Start.In(location).Format(timeutil.DateLayout)
 }

internal/report/definition.go

@@ -3,6 +3,7 @@ package report
 
 import (
 	"fmt"
+	"strings"
 	"time"
 
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
@@ -12,7 +13,8 @@ import (
 type ID string
 
 const (
-	DailyToday ID = "daily_today"
+	Daily    ID = "daily"
+	Today    ID = "today"
 	Tomorrow ID = "tomorrow"
 	Hourly   ID = "hourly"
 	ThreeDay ID = "three_day"
@@ -53,12 +55,14 @@ type Definition struct {
 	ComparisonStrategy       ComparisonStrategy
 	ArtifactGroup            string
 	BatchOutputName          string
+	DistributorPathTemplates []string
 	Generated                bool
 	CompatiblePriorIDs       []ID
 	Modules                  []module.ConfigItem
 	Morning                  bool
 	Evening                  bool
 	resolve                  func(ResolveRequest) (timeutil.Period, error)
+	runIDDisambiguator       func(Resolved) string
 }
 
 func (d Definition) ResolvePeriod(req ResolveRequest) (timeutil.Period, error) {
@@ -111,7 +115,7 @@ type Metadata struct {
 
 func (r Resolved) Metadata() Metadata {
 	return Metadata{
-		RunID:       r.GeneratedAt.UTC().Format("20060102T150405.000000000Z") + "_" + string(r.Definition.ID),
+		RunID:       r.runID(),
 		ReportID:    r.Definition.ID,
 		PromptID:    r.Definition.PromptID,
 		GeneratedAt: r.GeneratedAt,
@@ -119,3 +123,15 @@ func (r Resolved) Metadata() Metadata {
 		ValidPeriod: r.ValidPeriod,
 	}
 }
+
+func (r Resolved) runID() string {
+	runID := r.GeneratedAt.UTC().Format("20060102T150405.000000000Z") + "_" + string(r.Definition.ID)
+	if r.Definition.runIDDisambiguator == nil {
+		return runID
+	}
+	disambiguator := strings.TrimSpace(r.Definition.runIDDisambiguator(r))
+	if disambiguator == "" {
+		return runID
+	}
+	return runID + "_" + disambiguator
+}

internal/report/hourly_report.go

@@ -20,6 +20,9 @@ func hourlyDefinition() Definition {
 		ComparisonStrategy:    CompareRollingWindow,
 		ArtifactGroup:         "hourly",
 		BatchOutputName:       "hourly.md",
+		DistributorPathTemplates: []string{
+			"hourly/index.md",
+		},
 		Generated:          true,
 		CompatiblePriorIDs: []ID{Hourly},
 		Modules:            hourlyModules(),
@@ -35,12 +38,7 @@ func hourlyModules() []module.ConfigItem {
 		{ID: module.PrecipTiming},
 		{ID: module.AlertDigest},
 		{ID: module.SPCConvectiveOutlooks},
-		{
-			ID: module.AreaForecastDiscussion,
-			Options: module.AreaForecastDiscussionOptions{
-				Sections: []string{"key_messages", "short_term"},
-			},
-		},
+		areaForecastDiscussionItem("key_messages", "short_term"),
 		{ID: module.SPCConvectiveDiscussion},
 		{ID: module.WeatherStory},
 	}

internal/report/names.go

@@ -0,0 +1,92 @@
+package report
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	CommandNameDaily    = "daily"
+	CommandNameToday    = "today"
+	CommandNameTomorrow = "tomorrow"
+	CommandNameHourly   = "hourly"
+	CommandNameThreeDay = "three-day"
+	CommandNameWeekend  = "weekend"
+	CommandNameStorm    = "storm"
+
+	BatchNameMorning = "morning"
+	BatchNameEvening = "evening"
+)
+
+func IDForCommandName(name string) (ID, error) {
+	switch name {
+	case CommandNameDaily:
+		return Daily, nil
+	case CommandNameToday:
+		return Today, nil
+	case CommandNameTomorrow:
+		return Tomorrow, nil
+	case CommandNameHourly:
+		return Hourly, nil
+	case CommandNameThreeDay:
+		return ThreeDay, nil
+	case CommandNameWeekend:
+		return Weekend, nil
+	case CommandNameStorm:
+		return Storm, nil
+	default:
+		return "", fmt.Errorf("unknown report command %q", name)
+	}
+}
+
+func CommandNames() []string {
+	return []string{
+		CommandNameDaily,
+		CommandNameToday,
+		CommandNameTomorrow,
+		CommandNameHourly,
+		CommandNameThreeDay,
+		CommandNameWeekend,
+		CommandNameStorm,
+	}
+}
+
+func IDForConfigKey(key string) (ID, error) {
+	normalized := strings.ReplaceAll(strings.TrimSpace(strings.ToLower(key)), "-", "_")
+	switch normalized {
+	case "daily":
+		return Daily, nil
+	case "today":
+		return Today, nil
+	case "tomorrow":
+		return Tomorrow, nil
+	case "hourly":
+		return Hourly, nil
+	case "three_day", "three_day_outlook":
+		return ThreeDay, nil
+	case "weekend", "weekend_outlook":
+		return Weekend, nil
+	case "storm", "storm_report":
+		return Storm, nil
+	default:
+		return "", fmt.Errorf("report config key %q is not a known report", key)
+	}
+}
+
+func BatchForCommandName(name string) (Batch, error) {
+	switch name {
+	case BatchNameMorning:
+		return Morning, nil
+	case BatchNameEvening:
+		return Evening, nil
+	default:
+		return "", fmt.Errorf("unknown batch command %q", name)
+	}
+}
+
+func BatchCommandNames() []string {
+	return []string{
+		BatchNameMorning,
+		BatchNameEvening,
+	}
+}

internal/report/period.go

@@ -1,9 +1,6 @@
 package report
 
-import (
-	"fmt"
-	"time"
-)
+import "time"
 
 func Resolve(id ID, req ResolveRequest) (Resolved, error) {
 	return DefaultRegistry().Resolve(id, req)
@@ -17,39 +14,6 @@ func (r Registry) Resolve(id ID, req ResolveRequest) (Resolved, error) {
 	return r.resolveDefinition(definition, req)
 }
 
-func (r Registry) BatchReports(batch Batch, req ResolveRequest) ([]Resolved, error) {
-	if req.Location == nil {
-		req.Location = time.UTC
-	}
-	if req.Now.IsZero() {
-		req.Now = time.Now()
-	}
-	switch batch {
-	case Morning:
-		ids := []ID{DailyToday, ThreeDay}
-		if req.Now.In(req.Location).Weekday() != time.Sunday {
-			ids = append(ids, Weekend)
-		}
-		return r.resolveIDs(ids, req)
-	case Evening:
-		return r.resolveIDs([]ID{Tomorrow}, req)
-	default:
-		return nil, fmt.Errorf("unknown batch %q", batch)
-	}
-}
-
-func (r Registry) resolveIDs(ids []ID, req ResolveRequest) ([]Resolved, error) {
-	resolved := make([]Resolved, 0, len(ids))
-	for _, id := range ids {
-		item, err := r.Resolve(id, req)
-		if err != nil {
-			return nil, err
-		}
-		resolved = append(resolved, item)
-	}
-	return resolved, nil
-}
-
 func (r Registry) resolveDefinition(definition Definition, req ResolveRequest) (Resolved, error) {
 	if req.Location == nil {
 		req.Location = time.UTC

internal/report/period_test.go

@@ -14,11 +14,14 @@ func TestDailyValidPeriod(t *testing.T) {
 	location := mustLoadLocation(t)
 	now := mustParse("2026-05-29T17:45:00-05:00")
 
-	resolved, err := Resolve(DailyToday, ResolveRequest{Now: now, Location: location})
-	if err != nil {
-		t.Fatalf("Resolve() error = %v", err)
+	resolved, err := Resolve(Daily, ResolveRequest{Now: now, Location: location})
+	if err == nil {
+		t.Fatal("Resolve() error = nil, want explicit date requirement")
 	}
-	assertPeriod(t, resolved.ValidPeriod, "2026-05-29T00:00:00-05:00", "2026-05-30T00:00:00-05:00")
+	if !strings.Contains(err.Error(), "requires an explicit date") {
+		t.Fatalf("Resolve() error = %v, want explicit date requirement", err)
+	}
+	_ = resolved
 }
 
 func TestDailyValidPeriodCanUseExplicitDate(t *testing.T) {
@@ -26,7 +29,54 @@ func TestDailyValidPeriodCanUseExplicitDate(t *testing.T) {
 	now := mustParse("2026-05-29T17:45:00-05:00")
 	date := mustParse("2026-05-31T12:00:00-05:00")
 
-	resolved, err := Resolve(DailyToday, ResolveRequest{Now: now, Location: location, Date: date})
+	resolved, err := Resolve(Daily, ResolveRequest{Now: now, Location: location, Date: date})
+	if err != nil {
+		t.Fatalf("Resolve() error = %v", err)
+	}
+	assertPeriod(t, resolved.ValidPeriod, "2026-05-31T00:00:00-05:00", "2026-06-01T00:00:00-05:00")
+	if resolved.Definition.PromptID != "weather.daily_generated_text" {
+		t.Fatalf("PromptID = %q, want weather.daily_generated_text", resolved.Definition.PromptID)
+	}
+	if resolved.Definition.GenerationMode != GenerationModeGeneratedTextTemplate {
+		t.Fatalf("GenerationMode = %q, want generated_text_template", resolved.Definition.GenerationMode)
+	}
+	if resolved.Definition.TemplateID != "daily" {
+		t.Fatalf("TemplateID = %q, want daily", resolved.Definition.TemplateID)
+	}
+	if resolved.Definition.GeneratedTextSchemaID != "daily" {
+		t.Fatalf("GeneratedTextSchemaID = %q, want daily", resolved.Definition.GeneratedTextSchemaID)
+	}
+}
+
+func TestTodayValidPeriod(t *testing.T) {
+	location := mustLoadLocation(t)
+	now := mustParse("2026-05-29T17:45:00-05:00")
+
+	resolved, err := Resolve(Today, ResolveRequest{Now: now, Location: location})
+	if err != nil {
+		t.Fatalf("Resolve() error = %v", err)
+	}
+	assertPeriod(t, resolved.ValidPeriod, "2026-05-29T00:00:00-05:00", "2026-05-30T00:00:00-05:00")
+	if resolved.Definition.PromptID != "weather.today_generated_text" {
+		t.Fatalf("PromptID = %q, want weather.today_generated_text", resolved.Definition.PromptID)
+	}
+	if resolved.Definition.GenerationMode != GenerationModeGeneratedTextTemplate {
+		t.Fatalf("GenerationMode = %q, want generated_text_template", resolved.Definition.GenerationMode)
+	}
+	if resolved.Definition.TemplateID != "today" {
+		t.Fatalf("TemplateID = %q, want today", resolved.Definition.TemplateID)
+	}
+	if resolved.Definition.GeneratedTextSchemaID != "today" {
+		t.Fatalf("GeneratedTextSchemaID = %q, want today", resolved.Definition.GeneratedTextSchemaID)
+	}
+}
+
+func TestTodayValidPeriodCanUseExplicitDate(t *testing.T) {
+	location := mustLoadLocation(t)
+	now := mustParse("2026-05-29T17:45:00-05:00")
+	date := mustParse("2026-05-31T12:00:00-05:00")
+
+	resolved, err := Resolve(Today, ResolveRequest{Now: now, Location: location, Date: date})
 	if err != nil {
 		t.Fatalf("Resolve() error = %v", err)
 	}
@@ -191,52 +241,122 @@ func TestStormResolve(t *testing.T) {
 	}
 }
 
-func TestMorningBatchSkipsWeekendOnSunday(t *testing.T) {
-	location := mustLoadLocation(t)
-	resolved, err := DefaultRegistry().BatchReports(Morning, ResolveRequest{
-		Now:      mustParse("2026-05-31T06:00:00-05:00"),
-		Location: location,
-	})
-	if err != nil {
-		t.Fatalf("BatchReports() error = %v", err)
+func TestIDForCommandName(t *testing.T) {
+	tests := []struct {
+		name string
+		want ID
+	}{
+		{name: "daily", want: Daily},
+		{name: "today", want: Today},
+		{name: "tomorrow", want: Tomorrow},
+		{name: "hourly", want: Hourly},
+		{name: "three-day", want: ThreeDay},
+		{name: "weekend", want: Weekend},
+		{name: "storm", want: Storm},
 	}
-	ids := resolvedIDs(resolved)
-	if strings.Join(ids, ",") != "daily_today,three_day" {
-		t.Fatalf("ids = %v, want daily_today and three_day", ids)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := IDForCommandName(tt.name)
+			if err != nil {
+				t.Fatalf("IDForCommandName() error = %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("IDForCommandName() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+	if names := strings.Join(CommandNames(), ","); names != "daily,today,tomorrow,hourly,three-day,weekend,storm" {
+		t.Fatalf("CommandNames() = %s, want stable command names", names)
+	}
+	dailyID, err := IDForCommandName("daily")
+	if err != nil {
+		t.Fatalf("IDForCommandName(daily) error = %v", err)
+	}
+	todayID, err := IDForCommandName("today")
+	if err != nil {
+		t.Fatalf("IDForCommandName(today) error = %v", err)
+	}
+	if dailyID == todayID {
+		t.Fatalf("daily and today both resolve to %q, want distinct report IDs", dailyID)
+	}
+	if _, err := IDForCommandName("near-term"); err == nil || !strings.Contains(err.Error(), `unknown report command "near-term"`) {
+		t.Fatalf("IDForCommandName(near-term) error = %v, want unknown command", err)
 	}
 }
 
-func TestEveningBatchIncludesTomorrow(t *testing.T) {
-	location := mustLoadLocation(t)
-	resolved, err := DefaultRegistry().BatchReports(Evening, ResolveRequest{
-		Now:      mustParse("2026-05-29T18:00:00-05:00"),
-		Location: location,
-	})
-	if err != nil {
-		t.Fatalf("BatchReports() error = %v", err)
+func TestIDForConfigKey(t *testing.T) {
+	tests := []struct {
+		key  string
+		want ID
+	}{
+		{key: "daily", want: Daily},
+		{key: "today", want: Today},
+		{key: "tomorrow", want: Tomorrow},
+		{key: "hourly", want: Hourly},
+		{key: "three_day", want: ThreeDay},
+		{key: "three-day", want: ThreeDay},
+		{key: "three_day_outlook", want: ThreeDay},
+		{key: "three-day-outlook", want: ThreeDay},
+		{key: "weekend", want: Weekend},
+		{key: "weekend_outlook", want: Weekend},
+		{key: "storm", want: Storm},
+		{key: "storm_report", want: Storm},
 	}
-	ids := resolvedIDs(resolved)
-	if strings.Join(ids, ",") != "tomorrow" {
-		t.Fatalf("ids = %v, want tomorrow", ids)
+	for _, tt := range tests {
+		t.Run(tt.key, func(t *testing.T) {
+			got, err := IDForConfigKey(tt.key)
+			if err != nil {
+				t.Fatalf("IDForConfigKey() error = %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("IDForConfigKey() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+	if _, err := IDForConfigKey("daily_tomorrow"); err == nil || !strings.Contains(err.Error(), `report config key "daily_tomorrow" is not a known report`) {
+		t.Fatalf("IDForConfigKey(daily_tomorrow) error = %v, want unknown key", err)
+	}
+	retiredDailyKey := strings.Join([]string{"daily", "today"}, "_")
+	if _, err := IDForConfigKey(retiredDailyKey); err == nil || !strings.Contains(err.Error(), `report config key "`+retiredDailyKey+`" is not a known report`) {
+		t.Fatalf("IDForConfigKey(%s) error = %v, want unknown key", retiredDailyKey, err)
+	}
+	dailyID, err := IDForConfigKey("daily")
+	if err != nil {
+		t.Fatalf("IDForConfigKey(daily) error = %v", err)
+	}
+	todayID, err := IDForConfigKey("today")
+	if err != nil {
+		t.Fatalf("IDForConfigKey(today) error = %v", err)
+	}
+	if dailyID == todayID {
+		t.Fatalf("daily and today config keys both resolve to %q, want distinct report IDs", dailyID)
 	}
 }
 
-func TestBatchesDoNotIncludeHourly(t *testing.T) {
-	location := mustLoadLocation(t)
-	req := ResolveRequest{Now: mustParse("2026-05-29T06:00:00-05:00"), Location: location}
-
-	morning, err := DefaultRegistry().BatchReports(Morning, req)
+func TestBatchForCommandName(t *testing.T) {
+	tests := []struct {
+		name string
+		want Batch
+	}{
+		{name: "morning", want: Morning},
+		{name: "evening", want: Evening},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := BatchForCommandName(tt.name)
 			if err != nil {
-		t.Fatalf("BatchReports(morning) error = %v", err)
+				t.Fatalf("BatchForCommandName() error = %v", err)
 			}
-	evening, err := DefaultRegistry().BatchReports(Evening, req)
-	if err != nil {
-		t.Fatalf("BatchReports(evening) error = %v", err)
+			if got != tt.want {
+				t.Fatalf("BatchForCommandName() = %q, want %q", got, tt.want)
 			}
-	for _, resolved := range append(morning, evening...) {
-		if resolved.Definition.ID == Hourly {
-			t.Fatalf("batch included %q, want hourly excluded", resolved.Definition.ID)
+		})
 	}
+	if names := strings.Join(BatchCommandNames(), ","); names != "morning,evening" {
+		t.Fatalf("BatchCommandNames() = %s, want stable batch command names", names)
+	}
+	if _, err := BatchForCommandName("hourly"); err == nil || !strings.Contains(err.Error(), `unknown batch command "hourly"`) {
+		t.Fatalf("BatchForCommandName(hourly) error = %v, want unknown batch", err)
 	}
 }
 
@@ -252,7 +372,7 @@ func TestRegistryLookupErrorIsActionable(t *testing.T) {
 
 func TestRegistryAllIncludesHourlyInStableOrder(t *testing.T) {
 	ids := resolvedDefinitionIDs(DefaultRegistry().All())
-	want := []string{"daily_today", "tomorrow", "hourly", "three_day", "weekend", "storm"}
+	want := []string{"daily", "today", "tomorrow", "hourly", "three_day", "weekend", "storm"}
 	if strings.Join(ids, ",") != strings.Join(want, ",") {
 		t.Fatalf("All() ids = %#v, want %#v", ids, want)
 	}
@@ -277,7 +397,7 @@ func TestRegistryDefinitionsDeclareGenerationMetadata(t *testing.T) {
 		if !definition.Generated {
 			continue
 		}
-		if definition.ID == Hourly || definition.ID == Tomorrow {
+		if definition.ID == Hourly || definition.ID == Daily || definition.ID == Today || definition.ID == Tomorrow {
 			wantTemplate := string(definition.ID)
 			if definition.GenerationMode != GenerationModeGeneratedTextTemplate {
 				t.Fatalf("%s GenerationMode = %q, want %q", definition.ID, definition.GenerationMode, GenerationModeGeneratedTextTemplate)
@@ -312,11 +432,19 @@ func TestRegistryDefinitionsDeclarePathAndCompatibilityPolicy(t *testing.T) {
 		comparisonStrategy ComparisonStrategy
 	}{
 		{
-			id:                 DailyToday,
+			id:                 Daily,
 			artifactGroup:      "daily",
 			batchOutputName:    "daily.md",
 			generated:          true,
-			compatiblePriorIDs: []ID{DailyToday},
+			compatiblePriorIDs: []ID{Daily},
+			comparisonStrategy: CompareSameValidDate,
+		},
+		{
+			id:                 Today,
+			artifactGroup:      "today",
+			batchOutputName:    "today.md",
+			generated:          true,
+			compatiblePriorIDs: []ID{Today},
 			comparisonStrategy: CompareSameValidDate,
 		},
 		{
@@ -392,13 +520,114 @@ func TestRegistryDefinitionsDeclarePathAndCompatibilityPolicy(t *testing.T) {
 	}
 }
 
+func TestGeneratedRegistryDefinitionsDeclareDistributorPathDefaults(t *testing.T) {
+	for _, definition := range DefaultRegistry().All() {
+		if !definition.Generated {
+			continue
+		}
+		if len(definition.DistributorPathTemplates) == 0 {
+			t.Fatalf("%s DistributorPathTemplates is empty", definition.ID)
+		}
+	}
+}
+
+func TestRegistryDefinitionsDeclareDefaultDistributorPathTemplates(t *testing.T) {
+	tests := []struct {
+		id   ID
+		want []string
+	}{
+		{
+			id: Hourly,
+			want: []string{
+				"hourly/index.md",
+			},
+		},
+		{
+			id: Daily,
+			want: []string{
+				"daily/{valid_start_date}/{run_id}.md",
+				"daily/{valid_start_date}/index.md",
+			},
+		},
+		{
+			id: Today,
+			want: []string{
+				"daily/{valid_start_date}/{run_id}.md",
+				"daily/{valid_start_date}/index.md",
+				"today/index.md",
+			},
+		},
+		{
+			id: Tomorrow,
+			want: []string{
+				"daily/{valid_start_date}/{run_id}.md",
+				"daily/{valid_start_date}/index.md",
+				"tomorrow/index.md",
+			},
+		},
+		{
+			id: ThreeDay,
+			want: []string{
+				"three-day/{valid_start_date}/{run_id}.md",
+				"three-day/{valid_start_date}/index.md",
+			},
+		},
+		{
+			id: Weekend,
+			want: []string{
+				"weekend/{valid_start_date}/{run_id}.md",
+				"weekend/{valid_start_date}/index.md",
+			},
+		},
+		{
+			id: Storm,
+			want: []string{
+				"storm/{storm_id}/{run_id}.md",
+				"storm/{storm_id}/index.md",
+			},
+		},
+	}
+
+	registry := DefaultRegistry()
+	for _, tt := range tests {
+		t.Run(string(tt.id), func(t *testing.T) {
+			definition, err := registry.Lookup(tt.id)
+			if err != nil {
+				t.Fatalf("Lookup() error = %v", err)
+			}
+			if !reflect.DeepEqual(definition.DistributorPathTemplates, tt.want) {
+				t.Fatalf("DistributorPathTemplates = %#v, want %#v", definition.DistributorPathTemplates, tt.want)
+			}
+		})
+	}
+}
+
 func TestRegistryDefinitionsDeclareDefaultModules(t *testing.T) {
 	tests := []struct {
 		id   ID
 		want []module.ID
 	}{
 		{
-			id: DailyToday,
+			id: Daily,
+			want: []module.ID{
+				module.Metadata,
+				module.CurrentConditions,
+				module.NarrativeForecast,
+				module.DerivedDailySummary,
+				module.DerivedDaypartSummaries,
+				module.PrecipTiming,
+				module.AlertDigest,
+				module.SPCConvectiveOutlooks,
+				module.AreaForecastDiscussion,
+				module.SPCConvectiveDiscussion,
+				module.WeatherStory,
+				module.OutdoorWindows,
+				module.DailyPlanning,
+				module.HourlyForecast,
+			},
+		},
+		{
+			id: Today,
 			want: []module.ID{
 				module.Metadata,
 				module.CurrentConditions,
@@ -413,6 +642,7 @@ func TestRegistryDefinitionsDeclareDefaultModules(t *testing.T) {
 				module.WeatherStory,
 				module.OutdoorWindows,
 				module.HourlyForecast,
+				module.TodayPlanning,
 			},
 		},
 		{
@@ -510,7 +740,7 @@ func TestRegistryDefinitionsDeclareDefaultModules(t *testing.T) {
 func TestRegistryAppliesModuleOverridesWithoutChangingDefaults(t *testing.T) {
 	base := DefaultRegistry()
 	overridden, err := base.WithModuleOverrides(map[ID][]module.ConfigItem{
-		DailyToday: {
+		Daily: {
 			{ID: module.Metadata},
 			{ID: module.AlertDigest},
 		},
@@ -519,7 +749,7 @@ func TestRegistryAppliesModuleOverridesWithoutChangingDefaults(t *testing.T) {
 		t.Fatalf("WithModuleOverrides() error = %v", err)
 	}
 
-	definition, err := overridden.Lookup(DailyToday)
+	definition, err := overridden.Lookup(Daily)
 	if err != nil {
 		t.Fatalf("Lookup(overridden) error = %v", err)
 	}
@@ -527,13 +757,16 @@ func TestRegistryAppliesModuleOverridesWithoutChangingDefaults(t *testing.T) {
 		t.Fatalf("overridden ModuleIDs() = %#v, want metadata and alert digest", definition.ModuleIDs())
 	}
 
-	defaultDefinition, err := base.Lookup(DailyToday)
+	defaultDefinition, err := base.Lookup(Daily)
 	if err != nil {
 		t.Fatalf("Lookup(default) error = %v", err)
 	}
 	if len(defaultDefinition.ModuleIDs()) <= len(definition.ModuleIDs()) {
 		t.Fatalf("default ModuleIDs() = %#v, want original defaults unchanged", defaultDefinition.ModuleIDs())
 	}
+	if !reflect.DeepEqual(definition.DistributorPathTemplates, defaultDefinition.DistributorPathTemplates) {
+		t.Fatalf("overridden DistributorPathTemplates = %#v, want %#v", definition.DistributorPathTemplates, defaultDefinition.DistributorPathTemplates)
+	}
 }
 
 func TestRegistryRejectsModuleOverrideForUnknownReport(t *testing.T) {
@@ -550,19 +783,56 @@ func TestRegistryRejectsModuleOverrideForUnknownReport(t *testing.T) {
 
 func TestResolvedMetadata(t *testing.T) {
 	location := mustLoadLocation(t)
-	resolved, err := Resolve(DailyToday, ResolveRequest{Now: mustParse("2026-05-29T05:00:00-05:00"), Location: location})
+	resolved, err := Resolve(Daily, ResolveRequest{
+		Now:      mustParse("2026-05-29T05:00:00-05:00"),
+		Location: location,
+		Date:     mustParse("2026-05-29T12:00:00-05:00"),
+	})
 	if err != nil {
 		t.Fatalf("Resolve() error = %v", err)
 	}
 	metadata := resolved.Metadata()
-	if metadata.ReportID != DailyToday {
-		t.Fatalf("ReportID = %q, want daily_today", metadata.ReportID)
+	if metadata.ReportID != Daily {
+		t.Fatalf("ReportID = %q, want daily", metadata.ReportID)
 	}
-	if metadata.PromptID != "weather.daily_report" {
-		t.Fatalf("PromptID = %q, want weather.daily_report", metadata.PromptID)
+	if metadata.PromptID != "weather.daily_generated_text" {
+		t.Fatalf("PromptID = %q, want weather.daily_generated_text", metadata.PromptID)
 	}
-	if !strings.Contains(metadata.RunID, "daily_today") {
-		t.Fatalf("RunID = %q, want report id", metadata.RunID)
+	if metadata.RunID != "20260529T100000.000000000Z_daily_2026-05-29" {
+		t.Fatalf("RunID = %q, want dated Daily report id", metadata.RunID)
+	}
+}
+
+func TestDailyRunIDIncludesValidDateDisambiguator(t *testing.T) {
+	location := mustLoadLocation(t)
+	now := mustParse("2026-05-29T05:00:00-05:00")
+	first, err := Resolve(Daily, ResolveRequest{
+		Now:      now,
+		Location: location,
+		Date:     mustParse("2026-05-31T12:00:00-05:00"),
+	})
+	if err != nil {
+		t.Fatalf("Resolve(first) error = %v", err)
+	}
+	second, err := Resolve(Daily, ResolveRequest{
+		Now:      now,
+		Location: location,
+		Date:     mustParse("2026-06-01T12:00:00-05:00"),
+	})
+	if err != nil {
+		t.Fatalf("Resolve(second) error = %v", err)
+	}
+
+	firstRunID := first.Metadata().RunID
+	secondRunID := second.Metadata().RunID
+	if firstRunID == secondRunID {
+		t.Fatalf("Daily RunIDs both = %q, want distinct valid-date suffixes", firstRunID)
+	}
+	if firstRunID != "20260529T100000.000000000Z_daily_2026-05-31" {
+		t.Fatalf("first RunID = %q, want valid-date suffix", firstRunID)
+	}
+	if secondRunID != "20260529T100000.000000000Z_daily_2026-06-01" {
+		t.Fatalf("second RunID = %q, want valid-date suffix", secondRunID)
 	}
 }
 
@@ -579,8 +849,8 @@ func TestHourlyMetadataRunIDIncludesReportID(t *testing.T) {
 	if metadata.PromptID != "weather.hourly_generated_text" {
 		t.Fatalf("PromptID = %q, want weather.hourly_generated_text", metadata.PromptID)
 	}
-	if !strings.Contains(metadata.RunID, "hourly") {
-		t.Fatalf("RunID = %q, want report id", metadata.RunID)
+	if metadata.RunID != "20260529T101500.000000000Z_hourly" {
+		t.Fatalf("RunID = %q, want unchanged report id shape", metadata.RunID)
 	}
 }
 
@@ -597,14 +867,6 @@ func assertPeriod(t *testing.T, period timeutil.Period, wantStart string, wantEn
 	}
 }
 
-func resolvedIDs(resolved []Resolved) []string {
-	ids := make([]string, 0, len(resolved))
-	for _, item := range resolved {
-		ids = append(ids, string(item.Definition.ID))
-	}
-	return ids
-}
-
 func resolvedDefinitionIDs(definitions []Definition) []string {
 	ids := make([]string, 0, len(definitions))
 	for _, definition := range definitions {

internal/report/registry.go

@@ -12,7 +12,8 @@ type Registry struct {
 
 func DefaultRegistry() Registry {
 	definitions := []Definition{
-		dailyTodayDefinition(),
+		dailyDefinition(),
+		todayDefinition(),
 		tomorrowDefinition(),
 		hourlyDefinition(),
 		threeDayDefinition(),
@@ -29,8 +30,7 @@ func DefaultRegistry() Registry {
 func (r Registry) WithModuleOverrides(overrides map[ID][]module.ConfigItem) (Registry, error) {
 	next := Registry{definitions: map[ID]Definition{}}
 	for id, definition := range r.definitions {
-		definition.Modules = append([]module.ConfigItem(nil), definition.Modules...)
-		next.definitions[id] = definition
+		next.definitions[id] = cloneDefinition(definition)
 	}
 	for id, items := range overrides {
 		definition, ok := next.definitions[id]
@@ -43,6 +43,12 @@ func (r Registry) WithModuleOverrides(overrides map[ID][]module.ConfigItem) (Reg
 	return next, nil
 }
 
+func cloneDefinition(definition Definition) Definition {
+	definition.Modules = cloneModuleItems(definition.Modules)
+	definition.DistributorPathTemplates = append([]string(nil), definition.DistributorPathTemplates...)
+	return definition
+}
+
 func moduleItems(ids ...module.ID) []module.ConfigItem {
 	items := make([]module.ConfigItem, 0, len(ids))
 	for _, id := range ids {
@@ -51,6 +57,15 @@ func moduleItems(ids ...module.ID) []module.ConfigItem {
 	return items
 }
 
+func areaForecastDiscussionItem(sections ...string) module.ConfigItem {
+	return module.ConfigItem{
+		ID: module.AreaForecastDiscussion,
+		Options: module.AreaForecastDiscussionOptions{
+			Sections: append([]string(nil), sections...),
+		},
+	}
+}
+
 func cloneModuleItems(items []module.ConfigItem) []module.ConfigItem {
 	cloned := make([]module.ConfigItem, len(items))
 	copy(cloned, items)
@@ -74,7 +89,7 @@ func (r Registry) MustLookup(id ID) Definition {
 }
 
 func (r Registry) All() []Definition {
-	ids := []ID{DailyToday, Tomorrow, Hourly, ThreeDay, Weekend, Storm}
+	ids := []ID{Daily, Today, Tomorrow, Hourly, ThreeDay, Weekend, Storm}
 	out := make([]Definition, 0, len(ids))
 	for _, id := range ids {
 		if definition, ok := r.definitions[id]; ok {

internal/report/storm_report.go

@@ -17,6 +17,10 @@ func stormDefinition() Definition {
 		ComparisonStrategy: CompareExplicitWindow,
 		ArtifactGroup:      "storm",
 		BatchOutputName:    "storm.md",
+		DistributorPathTemplates: []string{
+			"storm/{storm_id}/{run_id}.md",
+			"storm/{storm_id}/index.md",
+		},
 		Generated:          true,
 		CompatiblePriorIDs: []ID{Storm},
 		Modules:            stormModules(),

internal/report/three_day_report.go

@@ -16,6 +16,10 @@ func threeDayDefinition() Definition {
 		ComparisonStrategy: CompareSameValidDate,
 		ArtifactGroup:      "three-day",
 		BatchOutputName:    "three-day.md",
+		DistributorPathTemplates: []string{
+			"three-day/{valid_start_date}/{run_id}.md",
+			"three-day/{valid_start_date}/index.md",
+		},
 		Generated:          true,
 		CompatiblePriorIDs: []ID{ThreeDay},
 		Modules:            threeDayModules(),

internal/report/today_report.go

@@ -0,0 +1,56 @@
+package report
+
+import (
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+)
+
+func todayDefinition() Definition {
+	return Definition{
+		ID:                    Today,
+		Name:                  "Today Report",
+		PromptID:              "weather.today_generated_text",
+		GenerationMode:        GenerationModeGeneratedTextTemplate,
+		TemplateID:            "today",
+		GeneratedTextSchemaID: "today",
+		ComparisonStrategy:    CompareSameValidDate,
+		ArtifactGroup:         "today",
+		BatchOutputName:       "today.md",
+		DistributorPathTemplates: []string{
+			"daily/{valid_start_date}/{run_id}.md",
+			"daily/{valid_start_date}/index.md",
+			"today/index.md",
+		},
+		Generated:          true,
+		CompatiblePriorIDs: []ID{Today},
+		Modules:            todayModules(),
+		Morning:            true,
+		resolve:            resolveToday,
+	}
+}
+
+func todayModules() []module.ConfigItem {
+	return moduleItems(
+		module.Metadata,
+		module.CurrentConditions,
+		module.NarrativeForecast,
+		module.DerivedDailySummary,
+		module.DerivedDaypartSummaries,
+		module.PrecipTiming,
+		module.AlertDigest,
+		module.SPCConvectiveOutlooks,
+		module.AreaForecastDiscussion,
+		module.SPCConvectiveDiscussion,
+		module.WeatherStory,
+		module.OutdoorWindows,
+		module.HourlyForecast,
+		module.TodayPlanning,
+	)
+}
+
+func resolveToday(req ResolveRequest) (timeutil.Period, error) {
+	if !req.Date.IsZero() {
+		return timeutil.CivilDay(req.Date, req.Location), nil
+	}
+	return timeutil.CivilDay(req.Now, req.Location), nil
+}

internal/report/tomorrow_report.go

@@ -0,0 +1,53 @@
+package report
+
+import (
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
+)
+
+func tomorrowDefinition() Definition {
+	return Definition{
+		ID:                    Tomorrow,
+		Name:                  "Tomorrow Report",
+		PromptID:              "weather.tomorrow_generated_text",
+		GenerationMode:        GenerationModeGeneratedTextTemplate,
+		TemplateID:            "tomorrow",
+		GeneratedTextSchemaID: "tomorrow",
+		ComparisonStrategy:    CompareSameValidDate,
+		ArtifactGroup:         "tomorrow",
+		BatchOutputName:       "tomorrow.md",
+		DistributorPathTemplates: []string{
+			"daily/{valid_start_date}/{run_id}.md",
+			"daily/{valid_start_date}/index.md",
+			"tomorrow/index.md",
+		},
+		Generated:          true,
+		CompatiblePriorIDs: []ID{Tomorrow},
+		Modules:            tomorrowModules(),
+		Evening:            true,
+		resolve:            resolveTomorrow,
+	}
+}
+
+func tomorrowModules() []module.ConfigItem {
+	return moduleItems(
+		module.Metadata,
+		module.CurrentConditions,
+		module.NarrativeForecast,
+		module.DerivedDailySummary,
+		module.DerivedDaypartSummaries,
+		module.PrecipTiming,
+		module.AlertDigest,
+		module.SPCConvectiveOutlooks,
+		module.AreaForecastDiscussion,
+		module.SPCConvectiveDiscussion,
+		module.WeatherStory,
+		module.OutdoorWindows,
+		module.TomorrowPlanning,
+		module.HourlyForecast,
+	)
+}
+
+func resolveTomorrow(req ResolveRequest) (timeutil.Period, error) {
+	return timeutil.CivilDay(req.Now.In(req.Location).AddDate(0, 0, 1), req.Location), nil
+}

internal/report/weekend_report.go

@@ -17,6 +17,10 @@ func weekendDefinition() Definition {
 		ComparisonStrategy: CompareWeekendWindow,
 		ArtifactGroup:      "weekend",
 		BatchOutputName:    "weekend.md",
+		DistributorPathTemplates: []string{
+			"weekend/{valid_start_date}/{run_id}.md",
+			"weekend/{valid_start_date}/index.md",
+		},
 		Generated:          true,
 		CompatiblePriorIDs: []ID{Weekend},
 		Modules:            weekendModules(),

internal/reporttemplate/prompts/daily.generated_text.md

@@ -0,0 +1,38 @@
+TASK: You are writing structured prose slots for a dated daily weather report.
+
+The calling application will render the final Markdown report. Your job is not to write the full report. Return only a JSON object matching the configured schema.
+
+Use only the supplied `data_package`. Do not invent weather details, times, hazards, probabilities, or impacts that are not supported by the data.
+
+The report focuses on the selected local civil day in `report.valid_period` for the configured location.
+
+Return these fields:
+
+- `summary`: required. 1-2 sentences summarizing the main weather story for the selected day.
+- `forecast_discussion`: required. 1 or more short paragraphs explaining the setup, timing, trend, or uncertainty most relevant to the selected day.
+- `precipitation_timing`: optional. Include only when the deterministic `precip_timing` module contains precipitation windows.
+- `confidence`: optional. Include only if uncertainty, timing spread, or conflicting signals materially affect how the reader should interpret the forecast.
+
+Return JSON only.
+
+# summary
+
+Lead with the most practical local outcome for the selected day. If an active warning is relevant during the report period, lead with the hazard.
+
+Mention the expected temperature character, precipitation risk, wind, visibility, heat, cold, or other hazards only when supported by the data package.
+
+# forecast_discussion
+
+Use deterministic module facts and narrative products to explain the most useful details for the selected day.
+
+Useful context may include:
+
+- timing of condition changes by daypart or hour
+- boundaries, forcing, moisture, instability, or storm mode when supported
+- active alerts or SPC outlooks that apply to the location
+- planning concerns surfaced by `daily_planning`
+- confidence or uncertainty
+
+# precipitation_timing
+
+Use 1-2 sentences to add practical precipitation context only when the data package contains deterministic precipitation windows. Include expected timing, type, intensity, duration, and uncertainty only when those details are supported.