Added a field with the current local date to the data package

.gitignore

@@ -1,5 +1,6 @@
-# Compiled application binary
+# Compiled application binary and testing workspace
 /weatherreporter
+/workspace
 
 # ---> Go
 # If you prefer the allow list template instead of the deny list, see community template:

docs/config.md

@@ -45,12 +45,25 @@ config test suite.
 - `timeout`: HTTP timeout duration. Default: `10s`.
 - `precision`: numeric precision query value. Default: `1`.
 - `units`: Weather API units query value. Default: `us`.
-- `timezone`: report timezone and Weather API timezone query value where supported. Default: `Chicago`.
+- `timezone`: report timezone and Weather API timezone query value where supported. Default: `America/Chicago`.
 - `format`: Weather API response format. Must be `json`. Default: `json`.
 
 Timezone values may be IANA names, configured aliases such as `Chicago` and
 `Stl`, US timezone abbreviations, or UTC offsets such as `-5` and `+09:30`.
 
+### `location`
+
+`location` is descriptive prompt context included in briefing metadata and
+Scriptorium data packages. It does not select a Weather API endpoint or enable
+multiple configured forecast locations.
+
+- `id`: short local identifier. Default: `home`.
+- `name`: human-readable location name. Default: `Brentwood`.
+- `region`: broader forecast area context. Default: `St. Louis Metro`.
+
+The prompt-facing location object also includes `timezone`, derived from the
+effective `weather_api.timezone` after CLI overrides such as `--tz`.
+
 ### `missing_source`
 
 - `default`: missing-source behavior for optional sources. One of `error`, `warn`, or `none`. Default: `warn`.
@@ -88,7 +101,7 @@ Each entry has:
 - `end`
 
 `start` and `end` use `HH:MM`. The default entries are overnight, morning,
-afternoon, and evening.
+midday, afternoon, and evening.
 
 ### `recent_change`
 

docs/integrations/weatherapi.md

@@ -28,9 +28,14 @@ Every response used by the adapter must be JSON with a top-level `data` field:
 }
 ```
 
-`data: null` is treated as a missing source. Missing optional sources follow the
-configured missing-source policy. Missing hourly forecast data fails bundle
-fetching because hourly periods are required for report generation.
+For most sources, `data: null` is treated as a missing source. Missing optional
+sources follow the configured missing-source policy. Missing hourly forecast
+data fails bundle fetching because hourly periods are required for report
+generation.
+
+`/alerts/active` is the exception: a successful response with `data: null`
+means the endpoint was checked and there are no current active alerts. The
+adapter records a non-missing alerts source and an empty alert run.
 
 Malformed JSON envelopes, non-2xx statuses, and response read failures include
 endpoint context in returned errors. Decode errors include source context when
@@ -92,9 +97,14 @@ Policy behavior:
 - `warn`: omit the source data, add a warning, and continue
 - `none`: omit the source data and continue without a warning
 
+For `/alerts/active`, an HTTP error or missing `data` field still fails or
+follows the relevant error path, but explicit `data: null` is not a
+missing-source condition.
+
 ## Source Identity
 
-For non-null source payloads, the adapter records:
+For source payloads accepted into the bundle, including the explicit `null`
+alerts payload, the adapter records:
 
 - source name
 - endpoint path
@@ -115,7 +125,7 @@ types in `internal/forecast/bundle.go`, including:
 - current condition values
 - forecast run metadata and `periods`
 - active alert run data
-- discussion metadata, key messages, and short/long-term sections
+- discussion metadata, key messages, and short/long-term section text
 
 The adapter intentionally keeps upstream transport and envelope details inside
 `internal/adapters/weatherapi`; downstream packages consume the normalized

docs/internal/app-orchestration.md

@@ -4,35 +4,46 @@ This document describes the implemented workflow coordinator in `internal/app`.
 
 ## Purpose
 
-`internal/app` coordinates top-level use cases: generating one report, running
-morning or evening batches, building inspectable briefing artifacts, fetching
-weather bundles, and reading existing artifacts for inspection.
+`internal/app` coordinates the top-level use cases after CLI parsing and config
+loading are complete. It resolves report definitions, fetches weather data,
+builds briefing and prompt-input artifacts, invokes Scriptorium through the
+adapter boundary, persists managed state, runs batches, and reads existing
+artifacts for inspection.
 
 ## Inputs And Outputs
 
 Inputs:
 
-- app request structs containing config, report or batch selection, clock time,
-  optional report date, optional Storm Report bounds, output paths, renderer
-  fakes, or state-store fakes
+- `GenerateRequest` for one report command
+- `BatchRequest` for morning or evening batch commands
+- `FetchBundleRequest` for explicit bundle fetch and save workflows
+- `BriefingRequest` and `ReportRequest` for package-level orchestration tests
+  and internal composition
 - resolved report definitions from `internal/report`
-- forecast bundles from the Weather API adapter
-- prior briefing snapshots from `internal/state`
+- forecast bundles from `internal/adapters/weatherapi`
+- prior snapshots loaded from `internal/state`
+- optional renderer and state-store fakes for tests
 
 Outputs:
 
-- report results with briefing, data package, preflight, report, metadata,
-  prior snapshot, Recent Changes, and Scriptorium results
-- batch summaries with per-report status and artifact paths
+- generated report results with briefing, data package, preflight, report,
+  metadata, prior snapshot, Recent Changes, and Scriptorium result details
+- batch summaries with per-report status, artifact paths, and error text
+- saved Weather API bundle JSON for fetch workflows
 - inspection JSON values for reports, metadata, briefings, data packages, prior
   snapshots, and source provenance
 
 ## Boundaries
 
-- The package coordinates workflow order.
-- It does not parse CLI flags, load YAML files directly, implement HTTP calls,
-  derive forecast facts, define report periods, compare Markdown, or construct
-  Scriptorium argv.
+`internal/app` owns workflow order and request composition. It does not parse
+CLI flags, load YAML files directly, implement HTTP transport, derive forecast
+facts, define report periods, compare rendered Markdown, or construct
+Scriptorium argv.
+
+Report selection and report identity policy come from `internal/report`.
+Weather API transport stays in `internal/adapters/weatherapi`. Scriptorium
+subprocess behavior stays in `internal/adapters/scriptorium`. Filesystem layout
+and persisted metadata stay in `internal/state`.
 
 ## Config Fields Used
 
@@ -42,36 +53,57 @@ Outputs:
 - `dayparts` for daily and outlook summarization
 - `recent_change.*` for structured Recent Changes thresholds
 
-## External Adapters Used
+Output copy flags are command request fields. They are not configuration
+defaults.
 
-- `internal/adapters/weatherapi` for forecast bundle fetching
-- `internal/adapters/scriptorium` for render preflight and report generation
-- `internal/state` filesystem store for persisted artifacts
+## Generation Workflow
 
-## State Or Manifest Behavior
+Single-report generation follows this order:
 
-Generation saves the briefing snapshot, data package, preflight result when
-available, rendered report, and metadata. Metadata links all managed artifact
-paths. Inspection workflows read existing state and do not fetch weather data or
-invoke Scriptorium.
+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 a report-specific briefing package.
+6. Save the briefing snapshot.
+7. Compute Recent Changes from structured prior and current briefings.
+8. Build and save the Scriptorium `data_package`.
+9. Run Scriptorium render preflight.
+10. Save preflight JSON when a render result is available.
+11. Save metadata for inspection.
+12. Run Scriptorium report generation to the managed report path.
+13. Copy the managed report to the requested `--out` path when provided.
+14. Save metadata with the managed report path.
 
-## Skip And Resume Behavior
+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.
 
-There is no resume workflow. Batch generation continues remaining independent
-reports after one report fails, then reports aggregate success and failure
-counts.
+## Batch Workflow
+
+`run morning` resolves Daily Today, 3-Day Outlook, and Weekend Outlook except
+on Sunday. `run evening` resolves Daily Tomorrow. Batch output copy names come
+from report definitions. 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.
+
+## Inspection Workflow
+
+Inspection workflows load existing filesystem state only. They do not fetch
+weather data or invoke Scriptorium. Run-specific inspect commands share the same
+store and metadata lookup path, then load the requested artifact or derived
+inspection view.
 
 ## Failure Behavior
 
 - Resolve errors stop the requested workflow before fetching weather data.
-- Weather API or briefing errors stop that report before Scriptorium is called.
-- Render preflight runs before Scriptorium report generation.
-- If render preflight returns 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,
-  metadata and the managed report path remain inspectable.
-- Batch failures are recorded per report and surfaced through aggregate batch
-  failure.
+- Weather API and briefing 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.
+- Metadata and artifact path errors include filesystem context.
+- Batch failures are recorded per report and surfaced through an aggregate
+  batch error.
 
 ## Tests
 
@@ -84,6 +116,8 @@ Inspect:
 ## Invariants
 
 - Report behavior is resolved through `internal/report`.
+- Generated reports use the same app request and result types regardless of
+  report ID.
 - Render preflight precedes Scriptorium report generation.
 - Recent Changes are computed from structured briefing snapshots.
 - Metadata links artifacts produced for a run.

docs/internal/briefing.md

@@ -16,12 +16,14 @@ Inputs:
 - resolved report definition, generation time, timezone, and valid period
 - forecast bundle with source provenance and warnings
 - derived daily or period summaries where required
-- configured units and timezone
+- configured units, timezone, and descriptive location context
 
 Outputs:
 
 - `briefing.Package` with common metadata and one report-specific content
   object for Daily, 3-Day, Weekend, or Storm Report
+- optional `currentConditions` prompt context from normalized
+  `/conditions/current` data when available
 - optional JSON file written by `briefing.Save`
 
 ## Boundaries
@@ -34,6 +36,10 @@ Outputs:
 
 The package receives configured units and timezone from the app layer. Daypart
 configuration is consumed by `internal/forecast` before briefing builders run.
+Configured `location` values are prompt context only; Weather API
+`sourceLocationId` and `sourceLocation` remain source provenance.
+Current conditions are copied from the normalized `/conditions/current` bundle
+source only; observation station and timestamp fields remain provenance.
 
 ## External Adapters Used
 
@@ -74,6 +80,6 @@ Inspect:
 
 - Briefings contain structured weather facts and source context.
 - Common metadata includes RunID, report ID, prompt ID, valid period, source
-  provenance, source hashes, and source warnings.
+  provenance, source hashes, source warnings, and configured prompt location.
 - LLM prompt input packaging and Scriptorium execution remain outside this
   boundary.

docs/internal/prompt-input.md

@@ -17,7 +17,12 @@ Inputs:
 Outputs:
 
 - `promptinput.Package` containing schema version, RunID, report metadata,
-  briefing content, Recent Changes, and source warnings
+  briefing content, Recent Changes, and source warnings. Briefing content
+  includes configured location context, current conditions when available,
+  discussion key messages, and short/long-term AFD narratives when the Weather
+  API provides them.
+- report metadata includes `currentLocalDate`, the generation date formatted as
+  `YYYY-MM-DD` in the effective report timezone.
 - optional JSON file written by `promptinput.Save`
 
 ## Boundaries
@@ -28,8 +33,8 @@ Outputs:
 
 ## Config Fields Used
 
-None directly. Config-derived values are already present in briefing metadata
-before this package runs.
+None directly. Config-derived values, including timezone and prompt location
+context, are already present in briefing metadata before this package runs.
 
 ## External Adapters Used
 

docs/internal/report-registry.md

@@ -1,57 +1,81 @@
 # Report Registry Internals
 
 This document describes report identity, valid-period resolution, batch
-membership, and comparison declarations in `internal/report`.
+membership, output naming, artifact grouping, and comparison declarations in
+`internal/report`.
 
 ## Purpose
 
-`internal/report` centralizes report definitions so report IDs, prompt IDs,
-default output names, comparison strategies, and valid periods are declared in
-one package.
+`internal/report` is the canonical source for report definitions. App, state,
+briefing, and CLI wiring consume resolved definitions instead of owning report
+identity policy themselves.
 
-## Inputs And Outputs
+## Definition Fields
 
-Inputs:
+Each report definition declares:
 
-- report ID or batch name
-- generation time
-- timezone
-- optional Daily date override
-- optional Storm Report start and end times
+- report ID and display name
+- Scriptorium prompt ID
+- valid-period resolver
+- comparison strategy
+- managed artifact group
+- batch output copy filename
+- generated-report eligibility
+- prior-report compatibility list
+- morning or evening batch membership
 
-Outputs:
+## Implemented Reports
 
-- `report.Resolved` values with definition metadata and half-open valid periods
-- `report.Metadata` values used by briefing and persisted metadata builders
+| Report | ID | Prompt | Artifact group | Batch copy | Prior compatibility |
+| --- | --- | --- | --- | --- | --- |
+| Daily Today | `daily_today` | `weather.daily_report` | `daily` | `daily.md` | Daily Today, Daily Tomorrow |
+| Daily Tomorrow | `daily_tomorrow` | `weather.daily_report` | `daily` | `tomorrow.md` | Daily Today, Daily Tomorrow |
+| 3-Day Outlook | `three_day` | `weather.three_day_outlook` | `three-day` | `three-day.md` | 3-Day Outlook |
+| Weekend Outlook | `weekend` | `weather.weekend_outlook` | `weekend` | `weekend.md` | Weekend Outlook |
+| Storm Report | `storm` | `weather.storm_report` | `storm` | `storm.md` | Storm Report |
+
+All implemented report definitions are eligible for generation.
+
+## Valid Periods
+
+- Daily Today covers the selected local civil day, or the current local civil
+  day when no date override is supplied.
+- Daily Tomorrow covers the next local civil day from generation time.
+- 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.
+- 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
+the configured timezone or RFC3339 timestamps with explicit offsets. End time
+must be after start time.
 
 ## Boundaries
 
-- This package defines report identity and time coverage only.
-- It does not fetch weather data, build briefings, compare snapshots, write
-  state, parse CLI flags, or invoke Scriptorium.
+`internal/report` defines report metadata and time coverage. It does not fetch
+weather data, build briefings, compare briefing 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.
 
 ## Config Fields Used
 
-The app supplies `weather_api.timezone` as a loaded `time.Location`. Report
-output path copying uses default output names from report definitions.
+The app supplies `weather_api.timezone` as a loaded `time.Location`. Batch
+output path copying uses batch output names from report definitions.
 
-## External Adapters Used
+## State And App Usage
 
-None.
-
-## State Or Manifest Behavior
-
-None directly. Resolved metadata contributes RunID, report ID, prompt ID,
-generation time, timezone, and valid period to later briefing and state
-metadata.
-
-## Skip And Resume Behavior
-
-No resume behavior. Morning batch resolution skips Weekend Outlook on Sunday.
+- State paths use `ArtifactGroup`.
+- Batch output copies use `BatchOutputName`.
+- Generation checks `Generated`.
+- Prior lookup checks `CompatiblePriorIDs` and the comparison strategy.
+- RunIDs include the resolved report ID.
 
 ## Failure Behavior
 
-- Unknown reports and batch names return actionable errors.
+- Unknown report IDs and batch names return actionable errors.
 - Weekend Outlook resolution returns an error when resolved directly on Sunday.
 - Storm Report resolution requires start and end, with end after start.
 
@@ -68,4 +92,6 @@ Inspect:
 - Report selection goes through the registry.
 - Daily Today and Daily Tomorrow both use `weather.daily_report`.
 - Valid periods are half-open intervals independent of rendered report text.
-- Comparison strategy is declared by report definition.
+- Artifact grouping, batch output filenames, generated-report eligibility,
+  comparison compatibility, and comparison strategy are declared by report
+  definition.

docs/internal/scriptorium-adapter.md

@@ -6,8 +6,9 @@ This document describes the subprocess adapter in
 ## Purpose
 
 The adapter runs `scriptorium render` for prompt preflight and `scriptorium run`
-for Markdown report generation while isolating subprocess details from domain
-packages.
+for Markdown report generation. It isolates subprocess execution, argv
+construction, timeout handling, output capture, and exit-code interpretation
+from app and domain packages.
 
 ## Inputs And Outputs
 
@@ -17,19 +18,25 @@ Inputs:
 - prompt input data package path
 - report output path for `run`
 - configured binary, config path, profile, timeout, and extra arguments
+- context for cancellation
 
 Outputs:
 
 - argv used for execution
-- captured stdout and stderr with truncation flags
+- captured stdout and stderr
+- truncation flags for captured output
 - exit code
 - report output path for `run`
 
 ## Boundaries
 
-- This adapter owns Scriptorium argv construction and subprocess execution.
-- It does not choose report types, build prompt input, fetch weather data,
-  decide workflow order, or persist workflow metadata.
+`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.
+
+The adapter exposes request and result structs for render and run operations.
+State persistence uses a state-owned preflight artifact shape; app
+orchestration converts render results before saving.
 
 ## Config Fields Used
 
@@ -39,29 +46,43 @@ Outputs:
 - `scriptorium.timeout`
 - `scriptorium.extra_args`
 
-## External Adapters Used
+## Commands
 
-- external `scriptorium` CLI
+Render preflight argv starts with:
 
-See [Scriptorium integration](../integrations/scriptorium.md) for the external
-CLI contract used by this project.
+```text
+scriptorium render --prompt <prompt_id> --input data_package=<path> --format json
+```
 
-## State Or Manifest Behavior
+Report generation argv starts with:
 
-`SaveRenderResult` can write render results atomically. The app and state store
-own managed preflight paths and metadata links.
+```text
+scriptorium run --prompt <prompt_id> --input data_package=<path> --out <path>
+```
 
-## Skip And Resume Behavior
+Configured `--config` and `--profile` flags are inserted after the subcommand
+and before prompt-specific arguments. Extra arguments are appended after the
+built-in arguments.
 
-None. Context cancellation and configured timeout stop subprocess execution.
+## Execution Behavior
+
+The adapter runs commands without shell interpolation. The same private
+execution path is used by render and run after command-specific request
+validation and argv construction.
+
+When `scriptorium.timeout` is greater than zero, each subprocess call uses a
+context with that timeout. Stdout and stderr are captured separately, capped at
+1 MiB each, and marked as truncated when the cap is reached.
 
 ## Failure Behavior
 
-- Missing prompt ID, data package path, or run output path returns an error.
-- Subprocess start or context errors are wrapped with operation context.
-- Nonzero render and run exits return captured output plus an error containing
-  exit code and stderr.
-- Captured stdout and stderr are size-limited and marked when truncated.
+- Missing prompt ID or data package path returns an error before subprocess
+  execution.
+- Missing run output path returns an error before subprocess execution.
+- Subprocess start errors, context cancellation, and timeouts are wrapped with
+  operation context by the caller-facing method.
+- Nonzero render and run exits return the captured result plus an error
+  containing the exit code and stderr.
 
 ## Tests
 
@@ -75,4 +96,5 @@ Inspect:
 
 - No shell interpolation is used.
 - The Scriptorium input name is `data_package`.
+- Render and run preserve command-specific result structs.
 - Scriptorium-specific flags stay inside adapter and config boundaries.

docs/internal/state.md

@@ -4,7 +4,7 @@ This document describes filesystem state in `internal/state`.
 
 ## Purpose
 
-`internal/state` owns managed artifact paths, atomic JSON writes, persisted
+`internal/state` owns managed workspace paths, atomic JSON writes, persisted
 metadata, prior snapshot lookup, and read-only artifact inspection helpers.
 
 ## Inputs And Outputs
@@ -15,7 +15,7 @@ Inputs:
 - resolved report definition and valid period
 - briefing package
 - prompt input data package
-- Scriptorium render result
+- preflight artifact
 - rendered report path preparation request
 - RunID for inspection lookups
 
@@ -32,10 +32,13 @@ Outputs:
 
 ## Boundaries
 
-- This package owns managed workspace layout, path validation, filesystem
-  writes, and metadata reads.
-- It does not fetch weather data, derive forecasts, build prompt input content,
-  compare briefing contents, invoke Scriptorium, or parse CLI flags.
+`internal/state` owns local filesystem layout, path validation, durable writes,
+metadata reads, prior lookup, and report listing. It does not fetch weather
+data, derive forecasts, build prompt input content, compare briefing contents,
+invoke Scriptorium, import adapter result types, or parse CLI flags.
+
+Preflight persistence uses the state-owned `PreflightArtifact` shape. The app
+converts adapter render results into that shape before saving.
 
 ## Config Fields Used
 
@@ -48,27 +51,48 @@ Outputs:
 Workspace subdirectories must be relative paths that stay under
 `workspace.root`.
 
-## External Adapters Used
+## Managed Layout
 
-- local filesystem
+Paths are derived from the resolved report definition's artifact group, the
+valid-period start date for JSON artifacts, and the RunID.
 
-## State Or Manifest Behavior
+```text
+<workspace.root>/
+  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.briefing.json
+  snapshots/<artifact_group>/<YYYY-MM-DD>/<run_id>.metadata.json
+  data-packages/<artifact_group>/<YYYY-MM-DD>/<run_id>.data_package.json
+  preflight/<artifact_group>/<YYYY-MM-DD>/<run_id>.render.json
+  reports/<artifact_group>/<run_id>.md
+```
 
-Managed paths are grouped by report family and valid-period start date for JSON
-artifacts. Reports are written under the report group. Metadata is stored beside
-briefing snapshots and links briefing, data package, preflight, and report
-paths. Report listing walks metadata files under the snapshots directory.
+Metadata is stored beside briefing snapshots and links the briefing, data
+package, preflight, report paths, and configured prompt location. Report
+listing walks metadata files under the snapshots directory.
 
-Prior snapshot lookup reads metadata and selects the latest earlier compatible
-snapshot. Daily Today and Daily Tomorrow are compatible with each other for the
-same valid local date. 3-Day Outlook compares with prior 3-Day snapshots for
-the same valid local date. Weekend Outlook compares with prior Weekend snapshots
-for the same weekend window. Storm Report currently has no prior lookup.
+## Prior Lookup
 
-## Skip And Resume Behavior
+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.
 
-There is no resume workflow. Missing metadata directories return no inspection
-records or no prior snapshot rather than creating state.
+- Daily Today and Daily Tomorrow are compatible with each other for the same
+  valid local date.
+- 3-Day Outlook compares with prior 3-Day snapshots for the same valid local
+  date.
+- Weekend Outlook compares with prior Weekend snapshots for the same weekend
+  window.
+- Storm Report currently has no prior lookup because explicit event-window
+  comparison is not searched by the filesystem store.
+
+## Writes And Inspection
+
+Durable JSON writes use shared atomic file helpers. Managed Markdown reports are
+prepared by creating their parent directory; Scriptorium writes the report body
+to the prepared path. Extra Markdown copies are handled by app orchestration.
+
+Inspection helpers read existing metadata, briefing, and data package files.
+Missing metadata directories return no inspection records or no prior snapshot
+rather than creating state.
 
 ## Failure Behavior
 
@@ -88,5 +112,6 @@ Inspect:
 ## Invariants
 
 - Managed paths stay under the configured workspace root.
+- Artifact grouping comes from report definitions.
 - Metadata links artifacts produced for a run.
 - Prior lookup is based on structured metadata, not rendered report text.

docs/internal/weather-data.md

@@ -6,7 +6,8 @@ This document describes Weather API ingestion into `forecast.Bundle`.
 
 `internal/adapters/weatherapi` fetches normalized weather data from one
 configured Weather API endpoint and assembles the bundle consumed by forecast
-derivation and briefing builders.
+derivation and briefing builders. Briefing builders expose normalized current
+conditions as prompt context when `/conditions/current` is available.
 
 ## Inputs And Outputs
 
@@ -53,8 +54,9 @@ contract used by this project.
 
 The adapter records source name, endpoint, query, fetch time, source timestamps
 when available, SHA-256 hash over compact raw `data` JSON, missing status, and
-source warnings. `app.FetchAndSaveBundle` can write bundle JSON atomically for
-inspection.
+source warnings. Successful `data: null` responses from `/alerts/active`
+represent a checked empty active-alert list, not a missing source.
+`app.FetchAndSaveBundle` can write bundle JSON atomically for inspection.
 
 ## Skip And Resume Behavior
 
@@ -69,6 +71,8 @@ data is required and cannot be skipped.
   endpoint context.
 - Missing hourly data or hourly forecasts with no periods fail bundle fetch.
 - Optional and stub sources follow missing-source policy.
+- Explicit `data: null` from `/alerts/active` produces an empty, non-missing
+  alert run.
 
 ## Tests
 

docs/policy/development.md

@@ -12,6 +12,7 @@ Developers and LLM coding agents should use it with
 - `internal/cli`: command parsing, flag handling, help text, and JSON output.
 - `internal/config`: configuration structs, defaults, loading, overrides, and
   validation.
+- `internal/fileutil`: shared atomic filesystem write and copy helpers.
 - `internal/adapters/weatherapi`: Weather API HTTP adapter.
 - `internal/adapters/scriptorium`: Scriptorium subprocess adapter.
 - `internal/forecast`: normalized bundle types and deterministic forecast

docs/roadmap/audit.md

@@ -1,553 +0,0 @@
-# Code Quality And Deduplication Audit
-
-## 1. Executive summary
-
-Overall code quality is good. The implementation is small, direct, and aligned
-with the documented architecture: CLI parsing is isolated in `internal/cli`,
-configuration is centralized in `internal/config`, report definitions live in
-`internal/report`, external systems sit behind adapters, and most domain logic
-is covered by focused tests.
-
-The codebase appears ready for a limited cleanup pass before the next major
-release. I did not find a major architectural risk that requires a broad
-rewrite.
-
-Top three refactoring targets:
-
-1. Centralize atomic file and JSON artifact writes. Similar write patterns now
-   exist in state, briefing, prompt input, Weather API bundle saving,
-   Scriptorium render saving, and report-copy code.
-2. Move report artifact naming, grouping, and compatibility policy closer to
-   the report registry. Related decisions are split across `internal/report`,
-   `internal/state`, and `internal/app`.
-3. Reduce repeated CLI/app inspection and config-loading scaffolding. The
-   inspect commands repeat parse/load/call/write patterns, and app inspection
-   repeats store and metadata lookup flows.
-
-Recommended cleanup should be incremental and behavior-preserving. Avoid a
-generic workflow engine, plugin layer, CLI redesign, or broad storage rewrite.
-
-## 2. Repository map reviewed
-
-Reviewed documentation and policy:
-
-- `README.md`
-- `docs/policy/architecture.md`
-- `docs/policy/development.md`
-- `docs/config.md`
-- `docs/cli.md`
-- `docs/operations.md`
-- `docs/troubleshooting.md`
-- `docs/internal/*`
-- `docs/integrations/*`
-- `docs/roadmap/*`
-- `examples/config.yml`
-- `examples/minimal-config.yml`
-
-Reviewed implementation packages:
-
-- `cmd/weatherreporter`
-- `internal/cli`
-- `internal/config`
-- `internal/app`
-- `internal/report`
-- `internal/forecast`
-- `internal/briefing`
-- `internal/promptinput`
-- `internal/changes`
-- `internal/state`
-- `internal/timeutil`
-- `internal/adapters/weatherapi`
-- `internal/adapters/scriptorium`
-
-Reviewed major execution paths:
-
-- `weatherreporter generate daily`
-- `weatherreporter generate tomorrow`
-- `weatherreporter generate three-day`
-- `weatherreporter generate weekend`
-- `weatherreporter generate storm`
-- `weatherreporter run morning`
-- `weatherreporter run evening`
-- `weatherreporter inspect reports`
-- `weatherreporter inspect metadata`
-- `weatherreporter inspect briefing`
-- `weatherreporter inspect data-package`
-- `weatherreporter inspect prior`
-- `weatherreporter inspect sources`
-
-Reviewed tests:
-
-- CLI parser and workflow tests under `internal/cli`
-- config/default/example tests under `internal/config`
-- app workflow tests under `internal/app`
-- adapter tests under `internal/adapters/*`
-- state path and prior-snapshot tests under `internal/state`
-- report period tests under `internal/report`
-- package-level tests for forecast, briefing, prompt input, and changes
-
-Areas not present in this repository: `internal/stage`, `internal/modules`,
-`internal/validators`, `internal/storage`, `internal/artifacts`,
-`internal/manifest`, `internal/schema`, `pkg`, remote storage, object-store
-keys, and persistent progress manifests.
-
-## 3. High-confidence deduplication opportunities
-
-### Centralize atomic file and JSON artifact writes
-
-- Affected files/packages: `internal/state/filesystem.go`,
-  `internal/briefing/package.go`, `internal/promptinput/package.go`,
-  `internal/adapters/weatherapi/client.go`,
-  `internal/adapters/scriptorium/runner.go`, `internal/app/app.go`.
-- Duplicated or near-duplicated behavior: multiple functions marshal JSON,
-  create parent directories, create temp files in the target directory, write,
-  close, rename, and defer temp-file cleanup. `copyFileAtomic` repeats the
-  same write path for Markdown report copies. `scriptorium.SaveRenderResult`
-  duplicates state preflight saving and does not appear to be used by the app.
-- Why it matters: atomic write behavior is part of the state and recovery
-  contract. A future bug fix around permissions, fsync behavior, temp-file
-  cleanup, Windows rename behavior, or error context would need to be applied
-  in several places.
-- Recommended refactor: add a small internal file helper, likely under
-  `internal/state` if kept state-specific or a narrow `internal/fileutil`
-  package if used by adapters too. Provide helpers such as `WriteFileAtomic`,
-  `WriteJSONAtomic`, and possibly `CopyFileAtomic`. Then remove unused
-  duplicate save helpers or route them through the shared helper.
-- Suggested tests: keep existing state, app, adapter, briefing, and prompt input
-  save tests. Add one focused helper test for parent-directory creation,
-  overwrite behavior, and temp-file cleanup on write errors if the helper is in
-  a new package.
-- Risk level: low. This is a behavior-preserving mechanical cleanup if error
-  messages are kept compatible where tests assert them.
-
-### Centralize report artifact grouping, naming, and compatibility policy
-
-- Affected files/packages: `internal/report`, `internal/state/filesystem.go`,
-  `internal/app/app.go`, state and app tests.
-- Duplicated or near-duplicated behavior: `internal/report` owns report IDs,
-  prompt IDs, default output names, batches, and comparison strategies.
-  `internal/state` separately maps report IDs to artifact groups such as
-  `daily`, `three-day`, `weekend`, and `storm`. `internal/app` separately
-  converts `DefaultOutputName` underscores to hyphens for batch output copies.
-  `internal/state` also hardcodes compatible prior report matching instead of
-  asking the report catalog.
-- Why it matters: adding or renaming a report requires updates in several
-  packages. A bug in grouping or compatibility could affect state lookup,
-  Recent Changes, managed paths, and batch output names.
-- Recommended refactor: extend `report.Definition` or add registry helpers for
-  artifact group, managed output group, batch copy filename, and compatible
-  prior report IDs. Keep filesystem path joining in `internal/state`, but move
-  report identity policy out of state/app. Preserve current path strings and
-  output filenames.
-- Suggested tests: strengthen `internal/report` tests to assert each definition
-  exposes group, copy filename, and compatibility policy. Keep existing
-  `internal/state` path tests and batch output tests as regression coverage.
-- Risk level: medium-low. The behavior is user-visible through artifact paths
-  and `--out-dir` names, so preserve exact strings.
-
-### Collapse repeated inspect command and app lookup flow
-
-- Affected files/packages: `internal/cli/root.go`, `internal/app/inspect.go`,
-  CLI and app inspect tests.
-- Duplicated or near-duplicated behavior: each inspect subcommand repeats flag
-  parsing, `config.Load`, app call, error handling, and JSON writing. The app
-  inspect functions repeatedly create the default store, load metadata by
-  RunID, and then load or derive a specific result.
-- Why it matters: adding another inspect view or changing config-loading/error
-  behavior would require edits in multiple cases. It also increases the chance
-  that one inspect command gains different output or error behavior.
-- Recommended refactor: add a small inspect command table in `internal/cli`
-  mapping command name to parser and handler. In `internal/app`, add an
-  internal helper that returns the store, metadata, and metadata path for a
-  RunID, then build briefing/data-package/prior/source views from that helper.
-- Suggested tests: keep the existing `TestRunInspectGeneratedArtifacts` and
-  missing metadata tests. Add a focused table test that each registered inspect
-  command accepts `--config` and rejects missing RunID where applicable.
-- Risk level: low. The refactor is local and should preserve public CLI output.
-
-### Remove or resolve unused report output config surface
-
-- Affected files/packages: `internal/config/config.go`,
-  `internal/config/load.go`, `internal/config/defaults.go`,
-  `internal/config/validate.go`, docs and examples if behavior changes.
-- Duplicated or near-duplicated behavior: `ReportOutputConfig` contains
-  `OutputDir` and `Paths`, and `LoadOptions.Output` writes to
-  `cfg.Reports.OutputDir`. Current command behavior uses `GenerateRequest`
-  `OutputPath` and `BatchRequest.OutputDir`; docs correctly say `--out` and
-  `--out-dir` control extra copies without changing config files. The report
-  output config fields do not appear to drive implemented behavior.
-- Why it matters: unused config fields are a maintenance hazard. They invite
-  future docs drift and make it unclear whether output policy belongs in config,
-  CLI requests, report definitions, or state.
-- Recommended refactor: decide one behavior before release. Either remove the
-  unused config surface and the `LoadOptions.Output` mutation, or implement
-  `reports.output_dir`/`reports.paths` as real defaults for generated extra
-  copies. Given current docs and CLI behavior, removal is the lower-risk option.
-- Suggested tests: config tests should assert only implemented config fields.
-  CLI tests should continue to cover `--out` and `--out-dir`.
-- Risk level: medium. This touches config structures and may affect users if
-  anyone has already copied old config fields, so pair the change with clear
-  release notes if removed.
-
-## 4. Medium-confidence opportunities
-
-### Reduce Weather API source fetch boilerplate
-
-- Affected files/packages: `internal/adapters/weatherapi/client.go`,
-  weather adapter tests.
-- Duplicated or near-duplicated behavior: optional source fetch methods repeat
-  request construction, missing handling, JSON decode, malformed-source policy,
-  source timestamp assignment, bundle assignment, and source recording. Hourly
-  is intentionally different because it is required and validates periods.
-- Why it matters: adding another Weather API source will likely copy this
-  structure and may accidentally diverge on missing-source policy or provenance.
-- Recommended refactor: introduce a small source specification/helper for
-  optional typed sources. Keep hourly special. Do not build a generic HTTP
-  ingestion framework.
-- Suggested tests: keep existing endpoint/query/missing-source tests. Add one
-  test that optional malformed data follows the configured missing-source
-  policy across at least two source specs.
-- Risk level: medium. The current explicit functions are readable; only refactor
-  if adding more source types or touching missing-source behavior.
-
-### Share Scriptorium render/run execution scaffolding
-
-- Affected files/packages: `internal/adapters/scriptorium/runner.go`,
-  Scriptorium adapter tests.
-- Duplicated or near-duplicated behavior: `Render` and `Run` both validate
-  common inputs, resolve binary/runner defaults, execute a command, copy
-  stdout/stderr/truncation/exit fields, and turn nonzero exit codes into
-  result-plus-error. Argument construction is already separated.
-- Why it matters: future changes to capture limits, redaction, timeout handling,
-  or nonzero exit formatting could drift between render and run.
-- Recommended refactor: introduce a private `execute` helper returning the
-  shared command result fields and preserving command-specific validation and
-  result structs.
-- Suggested tests: existing render/run argv and nonzero exit tests should remain
-  sufficient; add a timeout/non-exit error test if one is missing.
-- Risk level: low-medium. Keep the public adapter API and result JSON stable.
-
-### Consolidate storm time parsing and validation
-
-- Affected files/packages: `internal/cli/root.go`, `internal/report/period.go`,
-  CLI and report period tests.
-- Duplicated or near-duplicated behavior: CLI validates `--start`, `--end`,
-  parses both storm timestamps, and checks end after start. Report resolution
-  also validates storm start/end and has a `ParseStormPeriod` helper.
-- Why it matters: error wording and accepted timestamp behavior could drift
-  between CLI and report-level validation.
-- Recommended refactor: keep CLI-specific missing-flag errors in `internal/cli`,
-  but delegate parse/order validation to one helper after both values are
-  present.
-- Suggested tests: keep CLI tests for missing flags and RFC3339 parsing; keep
-  report period tests for invalid bounds.
-- Risk level: low.
-
-### Add a briefing-level weather signal helper, but keep prose local
-
-- Affected files/packages: `internal/briefing/daily.go`,
-  `internal/briefing/three_day.go`, `internal/briefing/weekend.go`,
-  `internal/briefing/storm.go`.
-- Duplicated or near-duplicated behavior: several builders aggregate ranges,
-  max precipitation, peak gusts, hazards, alert events, and risk labels from
-  daypart summaries. The report-specific prose and planning notes are
-  intentionally different.
-- Why it matters: threshold changes for "wind", "precipitation", or hazard
-  labels may need multiple edits.
-- Recommended refactor: add a narrow unexported helper in `internal/briefing`
-  for aggregating common signals from dayparts and alerts. Do not centralize
-  report-specific language, planning sections, or prompt-facing structure.
-- Suggested tests: briefing tests should assert unchanged daily, 3-day, weekend,
-  and storm package shape for representative fixtures.
-- Risk level: medium. This is useful only if kept small; over-consolidating
-  report prose would make the builders harder to read.
-
-### Clean up legacy daily-specific wrappers after generic report support
-
-- Affected files/packages: `internal/app/app.go`, `internal/state/store.go`,
-  `internal/state/filesystem.go`, app and state tests.
-- Duplicated or near-duplicated behavior: `DailyBriefingRequest`,
-  `DailyReportRequest`, `GenerateDailyBriefing`, `GenerateDailyReport`,
-  `BuildDailyBriefing`, `FindPriorDailySnapshot`, and `dailyRecentChanges`
-  mostly alias or forward to generic report functions.
-- Why it matters: wrappers create two names for the same behavior and encourage
-  future code to depend on the older daily-specific path.
-- Recommended refactor: remove unused wrappers or mark them as test-only
-  migration targets, then update tests to call the generic functions directly.
-  Keep any wrapper that is intentionally part of a public package contract, but
-  this repository uses `internal/`, so that concern is limited.
-- Suggested tests: app and state tests should continue to cover daily behavior
-  through generic generation and prior snapshot paths.
-- Risk level: low-medium. This is a small internal API cleanup, but it touches
-  many test call sites.
-
-### Reduce duplicated end-to-end test setup
-
-- Affected files/packages: `internal/cli/root_test.go`,
-  `internal/app/app_test.go`, adapter tests.
-- Duplicated or near-duplicated behavior: tests repeatedly create temp
-  workspaces, write YAML config strings, start representative Weather API
-  servers, create fake Scriptorium scripts, and glob managed artifact paths.
-- Why it matters: setup duplication makes behavior-preserving refactors noisier
-  and increases the chance that new tests accidentally use a subtly different
-  fixture.
-- Recommended refactor: add small package-local helpers for config writing,
-  test server setup, fake Scriptorium setup, and artifact glob/assertion.
-  Avoid a cross-package test framework unless duplication becomes painful in
-  more packages.
-- Suggested tests: this is test-only; existing tests should pass unchanged in
-  behavior.
-- Risk level: low.
-
-## 5. Boundary and responsibility concerns
-
-The main boundary concern is that `internal/state` imports the Scriptorium
-adapter package and exposes `SavePreflight(context.Context, report.Resolved,
-*scriptorium.RenderResult)` through `state.Store`. State needs to persist a
-preflight artifact, but it does not need to know that the artifact type comes
-from an external CLI adapter. This is a small leak across the documented adapter
-boundary.
-
-Recommended home: keep subprocess result construction in
-`internal/adapters/scriptorium`; have `internal/app` convert or pass the result
-to state through a state-owned preflight artifact type, a generic JSON artifact
-writer, or an app-owned persistence helper. This keeps adapter result types from
-becoming part of the state interface.
-
-The second boundary concern is report policy in state/app. `internal/state`
-should own filesystem layout mechanics, but report grouping and compatible
-prior report selection are report catalog decisions. `internal/app` should
-orchestrate batch copies, but batch copy filename policy should come from report
-definitions.
-
-The third concern is unused config surface. `internal/config` owns
-`ReportOutputConfig`, but current command behavior does not consume it. Either
-the app should use it explicitly or the config fields should be removed before
-they become accidental public API.
-
-## 6. Path, key, and naming construction review
-
-Local managed artifact paths are mostly centralized in
-`FilesystemStore.Paths`, which is good. That function owns the paths for
-briefing snapshots, metadata, data packages, preflight output, and managed
-Markdown reports.
-
-Cleanup targets:
-
-- `reportGroup` is private to `internal/state`, while report identity policy is
-  canonical in `internal/report`.
-- Batch extra-copy names are built in `internal/app` by replacing underscores in
-  `DefaultOutputName`. This derives a public filename by convention rather than
-  declaring it.
-- Metadata path resolution uses `metadataPathFromStored`, derived from
-  `BriefingPath`. This works today, but it means metadata path identity is
-  partially reconstructed from another artifact path instead of coming directly
-  from `ArtifactPaths`.
-- Tests in CLI/app/state hard-code path fragments in many places. These are
-  useful regression checks, but after report group/name helpers exist, tests
-  should assert through the helper or explicitly state they are path-contract
-  tests.
-
-No remote keys, cache paths, lock files, schema paths, or object-store paths are
-implemented.
-
-## 7. Resolution and catalog review
-
-Report resolution is mostly consistent. `internal/report` owns report
-definitions, prompt IDs, valid-period resolution, batches, and comparison
-strategy declarations.
-
-Places that should be brought closer to the catalog:
-
-- command-to-report mapping in `internal/app` (`ReportKind` to `report.ID`);
-- command-to-batch mapping in `internal/app`;
-- artifact group mapping in `internal/state`;
-- compatible prior report matching in `internal/state`;
-- batch copy filename behavior in `internal/app`;
-- "generated report" eligibility in `internal/app`.
-
-Recommendation: keep the public CLI command names in `internal/cli`/`app`, but
-let the report registry expose enough metadata that app and state do not need
-parallel switches over report IDs.
-
-Prompt and profile resolution is clean. Prompt IDs are declared in
-`internal/report`; Scriptorium profile/config/binary/extra args stay in config
-and the Scriptorium adapter. Data package naming is consistently
-`data_package=<path>`.
-
-Weather API source resolution is explicit but somewhat repetitive. A source
-catalog or source spec table could help if the number of upstream sources grows.
-
-## 8. Config and command-loading review
-
-Configuration loading is centralized in `internal/config`, and the documented
-precedence is reflected in code: CLI overrides, config file, built-in defaults.
-There is no duplicated YAML parsing or validation outside `internal/config`.
-
-Command loading is consistent but repetitive:
-
-- generate commands load config with `--config`, `--units`, `--tz`, and `--out`;
-- run commands load config with `--config`, `--units`, and `--tz`;
-- inspect commands load config with `--config` only.
-
-The inspect difference appears intentional because inspect commands do not
-fetch weather data or generate reports. The generate/run repetition is modest,
-but a small helper for building `config.LoadOptions` would reduce drift if more
-shared flags are added.
-
-The likely accidental issue is `LoadOptions.Output`: it mutates
-`cfg.Reports.OutputDir`, but current generation behavior separately uses
-`GenerateRequest.OutputPath`, and docs say output flags do not change config.
-This should be removed or given real semantics.
-
-## 9. State, manifest, or progress handling review
-
-The project has filesystem state but no manifest, checkpoint, resume, force, or
-dry-run system.
-
-State handling is generally consistent:
-
-- `FilesystemStore.Paths` centralizes managed artifact paths.
-- Store methods persist briefing, data package, preflight, metadata, and managed
-  report path preparation.
-- `GenerateReport` persists metadata before returning render errors when a
-  render result exists.
-- `RunBatchDetailed` continues independent reports and returns aggregate
-  results for CLI summarization.
-- Inspection loads metadata by RunID and then follows metadata paths.
-
-Cleanup targets:
-
-- State prior-snapshot lookup uses filesystem discovery plus hardcoded report
-  compatibility. This is currently acceptable, but compatibility policy should
-  be registry-driven before adding more report types.
-- `LoadMetadataByRunID` scans all reports through `ListReports`. This is simple
-  and fine at current scale, but it is the place to revisit if workspace size
-  grows.
-- `SaveMetadata` reconstructs the metadata path from `BriefingPath`, while most
-  other artifact paths come from `Paths`. Prefer carrying the metadata path
-  explicitly to reduce path coupling.
-
-No progress tracking drift exists because progress tracking is not implemented.
-
-## 10. Refactors to avoid
-
-Avoid these refactors for now:
-
-- A generic workflow engine for generation stages. The current explicit
-  orchestration is readable and well tested.
-- A plugin architecture for reports, sources, validators, or adapters. The
-  current registry and adapter packages are enough.
-- A broad CLI redesign or Cobra migration. The standard-library CLI is adequate
-  and documented.
-- A sweeping manifest or resume-system rewrite. There is no implemented resume
-  behavior to consolidate yet.
-- A generic source ingestion framework for the Weather API. A small helper or
-  spec table is enough if new sources are added.
-- Consolidating all report briefing prose. Similar thresholds can be factored,
-  but report-specific prompt inputs should remain readable and explicit.
-- Moving all test helpers into a global test package. Prefer package-local
-  helpers until duplication crosses package boundaries in a way that blocks
-  refactoring.
-- Removing path-contract tests merely because they duplicate strings. Some
-  hard-coded expected paths are valuable regression coverage.
-
-## 11. Recommended implementation sequence
-
-1. Path/key/naming helpers
-   - Add report registry metadata or helpers for artifact group, batch copy
-     filename, generated-report eligibility, and compatible prior report IDs.
-   - Preserve existing paths and filenames.
-   - Update state/app tests first or in the same commit.
-
-2. Atomic file and JSON helpers
-   - Introduce a narrow atomic file helper.
-   - Route state, briefing, prompt input, Weather API bundle saving,
-     Scriptorium preflight saving, and report-copy code through it.
-   - Remove unused save helpers if they no longer have callers.
-
-3. Config loading context
-   - Remove or implement `ReportOutputConfig` and `LoadOptions.Output`.
-   - Keep documented CLI output behavior stable.
-   - Add config regression tests around examples and CLI output flags.
-
-4. Command preflight/shared CLI parsing
-   - Add small helpers for common config-load options and inspect command
-     dispatch.
-   - Keep command errors and JSON output stable.
-
-5. Shared state lookup helpers
-   - Add app or state helpers for "load metadata by RunID, then load artifact".
-   - Keep inspect output unchanged.
-
-6. Adapter workflow cleanup
-   - Factor Scriptorium shared execution internals.
-   - Consider a Weather API optional-source helper only if source work is
-     already planned.
-
-7. Formatting/reporting cleanup
-   - Collapse `writeRunSummary` and `writeJSON` into one JSON writer helper.
-   - Leave stderr run logs as-is unless operator output requirements change.
-
-8. Test helper and fixture cleanup
-   - Add package-local helpers for repeated CLI/app setup.
-   - Keep fixtures small and deterministic.
-
-9. Dead-code/legacy sweep
-   - Remove daily-specific wrapper aliases and `FindPriorDailySnapshot` after
-     tests call generic paths.
-   - Re-run full tests and update internal docs if any package contracts change.
-
-## 12. Test strategy
-
-Tests to run before refactoring:
-
-- `go test ./internal/report ./internal/state`
-- `go test ./internal/app ./internal/cli`
-- `go test ./internal/config`
-- `go test ./internal/adapters/weatherapi ./internal/adapters/scriptorium`
-
-Tests to add before or during cleanup:
-
-- Report registry tests for artifact group, batch copy filename, generated
-  eligibility, and compatible prior report IDs.
-- Atomic file helper tests for parent directory creation, overwrite behavior,
-  and cleanup after write failure.
-- Config tests proving output flags do not mutate config, or tests defining the
-  implemented behavior if `reports.output_dir` is kept.
-- CLI inspect table tests that cover `--config` parsing and missing RunID
-  validation for each run-specific inspect command.
-- State tests that assert metadata path is taken from explicit artifact paths if
-  `metadataPathFromStored` is removed.
-- Scriptorium adapter tests for shared nonzero exit and timeout handling after
-  render/run execution is factored.
-
-Tests that can accompany refactors:
-
-- Weather API optional-source helper tests if source fetch boilerplate is
-  factored.
-- Briefing fixture tests if common signal aggregation is factored.
-- Test-helper cleanup can rely on existing package tests if no production code
-  changes.
-
-## 13. Appendix: findings not worth acting on
-
-- `internal/app.BuildBriefing` uses a switch over report IDs. This is acceptable
-  because app orchestration needs to dispatch to report-specific builders. A
-  registry of builder functions could be useful later, but it is not necessary
-  for the current report count.
-- CLI command parsing is explicit and somewhat repetitive. Do not replace it
-  with a framework. Small helpers are enough.
-- Daily, 3-day, weekend, and storm briefing builders have similar weather
-  thresholds. Some signal aggregation can be shared, but report-specific
-  sections and wording should stay local.
-- Weather API fetch methods are explicit. A helper is worthwhile only around
-  repeated optional-source mechanics; endpoint-specific decode and timestamp
-  behavior should remain clear.
-- Hard-coded expected artifact path fragments in tests duplicate path strings,
-  but several of those tests intentionally protect the on-disk contract.
-- `LoadMetadataByRunID` scans filesystem metadata. That is acceptable at the
-  current scale and should not be optimized without evidence of operational
-  pain.
-- Batch stderr logs are simple text. Do not introduce a logging subsystem unless
-  operator requirements become more complex.

docs/roadmap/cleanup.md

@@ -1,394 +0,0 @@
-# Cleanup Roadmap
-
-## Purpose
-
-This roadmap defines the staged implementation plan for the code quality and
-deduplication cleanup identified in `docs/roadmap/audit.md`.
-
-The target audience is an LLM coding agent. Implement each stage in order.
-Each stage should leave the repository buildable, tested, and behaviorally
-equivalent unless the stage explicitly removes unused public-facing surface.
-
-## Cleanup Principles
-
-- Preserve public CLI syntax and output behavior unless a stage explicitly says
-  otherwise.
-- Preserve current managed artifact paths, report group names, RunID naming,
-  and batch output copy filenames.
-- Keep domain policy in `internal/report`, `internal/forecast`,
-  `internal/briefing`, and `internal/changes`, not in CLI or adapter packages.
-- Keep external system details behind adapter boundaries.
-- Prefer narrow, behavior-preserving helpers over broad framework-style
-  abstractions.
-- Add or update focused tests in the package that owns the behavior being
-  cleaned up.
-- Update non-roadmap documentation only after implemented behavior changes.
-- Do not revert unrelated worktree changes.
-
-## Decisions Locked
-
-- Add a narrow `internal/fileutil` package for reusable atomic file helpers.
-- Remove the unused `reports` config surface instead of implementing
-  config-driven output defaults.
-- Move report artifact group, batch copy filename, generated-report eligibility,
-  and compatible-prior policy into `internal/report`.
-- Keep public CLI command names and command-to-report mapping in `internal/app`
-  for now.
-- Do not include Weather API source-spec refactoring in the main cleanup
-  sequence.
-- Do not include broad briefing signal consolidation in the main cleanup
-  sequence.
-- Do not introduce Cobra, a workflow engine, plugin system,
-  manifest/resume/progress system, logging subsystem, or global test framework.
-- Treat the current unrelated deletion of `docs/roadmap/documentation.md` as
-  out of scope for cleanup implementation. Do not restore or further modify it
-  unless a later prompt explicitly asks for that.
-
-## Stage 1: Report Catalog And Path Policy
-
-Goal: make `internal/report` the canonical source for report identity policy.
-
-Implementation:
-
-- Extend `report.Definition` with:
-  - `ArtifactGroup string`
-  - `BatchOutputName string`
-  - `Generated bool`
-  - `CompatiblePriorIDs []report.ID`
-- Populate current exact values:
-  - Daily Today: artifact group `daily`, batch output `daily.md`, generated
-    true, compatible with Daily Today and Daily Tomorrow.
-  - Daily Tomorrow: artifact group `daily`, batch output `tomorrow.md`,
-    generated true, compatible with Daily Today and Daily Tomorrow.
-  - 3-Day: artifact group `three-day`, batch output `three-day.md`, generated
-    true, compatible with 3-Day.
-  - Weekend: artifact group `weekend`, batch output `weekend.md`, generated
-    true, compatible with Weekend.
-  - Storm: artifact group `storm`, batch output `storm.md`, generated true,
-    compatible with Storm.
-- Add small methods or helpers in `internal/report` for compatibility checks if
-  direct slice checks would duplicate logic in callers.
-- Update `internal/state` to use the resolved report definition's
-  `ArtifactGroup` instead of private `reportGroup`.
-- Update prior snapshot lookup to use `CompatiblePriorIDs` instead of a
-  state-owned compatibility switch.
-- Update `internal/app` to use `BatchOutputName` directly and remove
-  underscore-to-hyphen derivation.
-- Update generated-report eligibility checks to use `Definition.Generated`.
-- Preserve all existing managed artifact paths and batch copy filenames.
-
-Tests:
-
-- Add or update report registry tests that assert each definition's
-  `ArtifactGroup`, `BatchOutputName`, `Generated`, and `CompatiblePriorIDs`.
-- Keep state path tests as path-contract tests and preserve their expected path
-  strings.
-- Keep app batch output tests and preserve expected filenames such as
-  `tomorrow.md`.
-- Run:
-
-```bash
-go test ./internal/report ./internal/state ./internal/app
-```
-
-Acceptance criteria:
-
-- No report grouping switch remains in `internal/state`.
-- No batch output filename derivation by underscore replacement remains in
-  `internal/app`.
-- Existing artifact paths and output copy names are unchanged.
-
-## Stage 2: Atomic Artifact Writes And Adapter Boundary
-
-Goal: centralize durable write mechanics and remove adapter type leakage from
-state.
-
-Implementation:
-
-- Add `internal/fileutil` with:
-  - `WriteFileAtomic(path string, data []byte) error`
-  - `WriteJSONAtomic(path string, value any) error`
-  - `CopyFileAtomic(source string, target string) error`
-- Implement helpers with the current behavior:
-  - create parent directories with `0o755`;
-  - create temp files in the target directory;
-  - write, close, rename, and defer temp-file cleanup;
-  - preserve useful path context in errors.
-- Route these through `internal/fileutil`:
-  - state JSON writes;
-  - briefing package save;
-  - prompt input package save;
-  - Weather API bundle save;
-  - Scriptorium render result save if the helper remains;
-  - generated report extra-copy writes.
-- Remove duplicate private atomic write helpers once callers are migrated.
-- Remove `scriptorium.SaveRenderResult` if no caller still needs it after the
-  refactor.
-- Add `state.PreflightArtifact` with the same persisted JSON shape currently
-  produced from `scriptorium.RenderResult`.
-- Change `state.Store.SavePreflight` to accept `state.PreflightArtifact`, not
-  `*scriptorium.RenderResult`.
-- Convert `scriptorium.RenderResult` to `state.PreflightArtifact` in
-  `internal/app` immediately before saving preflight output.
-- Keep subprocess result construction and interpretation in
-  `internal/adapters/scriptorium`.
-
-Tests:
-
-- Add `internal/fileutil` tests for parent directory creation, overwrite
-  behavior, and cleanup/error behavior.
-- Keep state, app, adapter, briefing, and prompt input save tests.
-- Run:
-
-```bash
-go test ./internal/fileutil ./internal/state ./internal/app ./internal/briefing ./internal/promptinput ./internal/adapters/weatherapi ./internal/adapters/scriptorium
-```
-
-Acceptance criteria:
-
-- Durable JSON and Markdown copy writes share one implementation.
-- `internal/state` no longer imports `internal/adapters/scriptorium`.
-- Persisted preflight JSON remains shape-compatible with current artifacts.
-
-## Stage 3: Remove Unused Report Output Config
-
-Goal: remove config fields that do not affect implemented behavior.
-
-Implementation:
-
-- Remove these unused config surfaces:
-  - `Config.Reports`
-  - `ReportOutputConfig`
-  - `LoadOptions.Output`
-  - default report output config values;
-  - `reports.output_dir` validation;
-  - `reports.paths` map initialization.
-- Update CLI generation config loading so `--out` remains only
-  `GenerateRequest.OutputPath`.
-- Keep `--out` and `--out-dir` behavior unchanged.
-- Update config tests and examples so they mention only implemented config
-  fields.
-- Update documentation in the same stage if non-roadmap docs still mention the
-  removed `reports` config surface.
-
-Tests:
-
-- Update config tests to assert config loading no longer has output-related
-  config behavior.
-- Keep CLI tests for `--out` and `--out-dir`.
-- Run:
-
-```bash
-go test ./internal/config ./internal/cli ./internal/app
-go run ./cmd/weatherreporter --help
-```
-
-Acceptance criteria:
-
-- No `ReportOutputConfig` or `LoadOptions.Output` symbols remain.
-- Example config files load through existing config tests.
-- CLI output-copy behavior remains command request behavior, not config behavior.
-
-## Stage 4: Inspect Command And State Lookup Cleanup
-
-Goal: remove repeated inspect scaffolding while preserving inspect output.
-
-Implementation:
-
-- Add a small inspect command table in `internal/cli`.
-- Keep `inspect reports` separate because it accepts `--limit` and does not
-  require a RunID.
-- For run-specific inspect commands, centralize:
-  - command name;
-  - flag parsing;
-  - config loading;
-  - app handler invocation;
-  - JSON output writing.
-- In `internal/app`, add an unexported helper that loads the default store and
-  metadata for a RunID.
-- Use the app helper for metadata, briefing, data-package, prior, and sources
-  inspection.
-- Collapse `writeRunSummary` and `writeJSON` into one JSON writer helper.
-- Preserve current JSON indentation and output shapes.
-
-Tests:
-
-- Keep `TestRunInspectGeneratedArtifacts`.
-- Keep missing metadata tests.
-- Add a table test proving run-specific inspect commands reject missing RunID
-  and accept `--config`.
-- Run:
-
-```bash
-go test ./internal/cli ./internal/app ./internal/state
-```
-
-Acceptance criteria:
-
-- Inspect command output is unchanged.
-- Config loading remains consistent across inspect commands.
-- Repeated store and metadata lookup code in app inspection paths is removed.
-
-## Stage 5: Small Adapter And Parser Deduplication
-
-Goal: reduce low-risk repeated validation and execution logic.
-
-Implementation:
-
-- In `internal/adapters/scriptorium`, add a private execution helper shared by
-  `Render` and `Run`.
-- Keep command-specific request validation and result structs.
-- Preserve:
-  - argv order;
-  - result JSON fields;
-  - stdout/stderr capture;
-  - truncation fields;
-  - timeout behavior;
-  - nonzero exit behavior and error text.
-- In storm CLI parsing, keep CLI-specific missing `--start` and `--end` errors.
-- After both storm bounds are present, delegate timestamp parsing and
-  end-after-start validation to `report.ParseStormPeriod`.
-- Do not introduce a generic Weather API ingestion framework in this stage.
-
-Tests:
-
-- Keep or add tests for Scriptorium render/run nonzero exits.
-- Keep storm tests for local timestamps, RFC3339 timestamps, missing flags, and
-  invalid bounds.
-- Run:
-
-```bash
-go test ./internal/adapters/scriptorium ./internal/cli ./internal/report
-```
-
-Acceptance criteria:
-
-- Scriptorium render/run behavior remains byte-for-byte compatible where tests
-  assert argv or output shape.
-- Storm accepted timestamp formats and error behavior remain stable.
-
-## Stage 6: Legacy Wrapper And Test Helper Cleanup
-
-Goal: remove stale generic-vs-daily duplication and reduce noisy test setup.
-
-Implementation:
-
-- Replace tests and internal callers of:
-  - `GenerateDailyBriefing`
-  - `GenerateDailyReport`
-  - `BuildDailyBriefing`
-  - `DailyBriefingRequest`
-  - `DailyReportRequest`
-- Use generic functions and types instead:
-  - `GenerateBriefing`
-  - `GenerateReport`
-  - `BuildBriefing`
-  - `BriefingRequest`
-  - `ReportRequest`
-- Remove `FindPriorDailySnapshot` from `state.Store` and
-  `FilesystemStore` after tests use `FindPriorSnapshot`.
-- Remove `dailyRecentChanges` if no callers remain.
-- Add package-local test helpers in `internal/cli` and `internal/app` for:
-  - writing test config files;
-  - fake Scriptorium setup;
-  - representative Weather API test server setup;
-  - artifact glob and assertion helpers.
-- Do not create a cross-package test framework.
-
-Tests:
-
-- Run:
-
-```bash
-go test ./internal/app ./internal/state ./internal/cli
-go test ./internal/...
-```
-
-Acceptance criteria:
-
-- Daily-specific app/state wrapper symbols listed above are gone.
-- Daily behavior remains covered through generic report-generation paths.
-- Test helper extraction does not reduce workflow coverage.
-
-## Stage 7: Documentation And Final Validation
-
-Goal: align implemented documentation after cleanup.
-
-Implementation:
-
-- Update non-roadmap docs only for behavior or internal contracts actually
-  changed by stages 1 through 6.
-- Inspect and update, as needed:
-  - `docs/config.md`
-  - `docs/internal/state.md`
-  - `docs/internal/scriptorium-adapter.md`
-  - `docs/internal/report-registry.md`
-  - `docs/policy/development.md`
-  - relevant files under `docs/integrations/`
-- Keep future or deferred cleanup ideas only under `docs/roadmap/`.
-- Do not document deferred Weather API source-spec or briefing signal refactors
-  as implemented.
-
-Validation:
-
-```bash
-go test ./...
-go run ./cmd/weatherreporter --help
-git diff --check
-```
-
-Run stale-symbol searches:
-
-```bash
-rg -n "ReportOutputConfig|LoadOptions\\.Output|FindPriorDailySnapshot|GenerateDailyReport|DailyReportRequest|SaveRenderResult" .
-```
-
-Review any matches manually. Matches under roadmap files may be acceptable
-because they describe planned or completed cleanup work.
-
-Acceptance criteria:
-
-- Non-roadmap docs describe only implemented behavior.
-- Config examples still load through config tests.
-- CLI help remains accurate.
-- No removed production symbols remain outside tests or roadmap references.
-
-## Deferred Refactors
-
-Do not include these in the main cleanup sequence:
-
-- Weather API optional-source spec/helper refactor.
-- Broad briefing weather-signal consolidation.
-- Generic workflow engine.
-- Plugin architecture.
-- Cobra migration.
-- Manifest/resume/progress system.
-- Global test helper package.
-- Logging subsystem.
-
-These can be revisited only when new source types, report types, or operational
-requirements make the duplication materially more expensive.
-
-## Global Validation Checklist
-
-Run focused tests after each stage, then run full validation after Stage 7.
-
-Required final checks:
-
-```bash
-go test ./...
-go run ./cmd/weatherreporter --help
-git diff --check
-```
-
-Required manual checks:
-
-- Public CLI syntax remains stable.
-- Managed artifact paths remain stable.
-- Batch output copy filenames remain stable.
-- `scriptorium` argv construction remains stable.
-- Weather API request query behavior remains stable.
-- Removed config fields are also removed from current-behavior docs and
-  examples.
-- Roadmap files are the only docs that describe deferred cleanup work.
-- No unrelated worktree changes are reverted.

docs/roadmap/future.md

@@ -49,3 +49,38 @@ These ideas are not current behavior:
 
 Each item needs its own design note before implementation. Non-roadmap docs
 must not describe these as available behavior.
+
+## Deferred: Cleanup Refactors
+
+The initial cleanup pass intentionally left these refactors out because the
+current implementation does not yet make them worth the added abstraction.
+
+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 briefing
+  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.
+- Plugin architecture: defer until there is a concrete external extension
+  contract and at least one implemented extension point.
+- 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.
+
+Any future implementation should preserve the existing public CLI, artifact
+paths, report identities, and adapter boundaries unless a separate roadmap
+explicitly changes them.

examples/config.yml

@@ -1,11 +1,16 @@
 weather_api:
-  base_url: https://weather.api.example.com/
+  base_url: https://weather.api.rakestrawhome.com/
   timeout: 15s
   precision: 1
   units: us
-  timezone: Chicago
+  timezone: "America/Chicago"
   format: json
 
+location:
+  id: home
+  name: Brentwood
+  region: St. Louis Metro
+
 missing_source:
   default: warn
   sources:
@@ -28,12 +33,15 @@ dayparts:
     end: "06:00"
   - name: morning
     start: "06:00"
-    end: "12:00"
+    end: "10:00"
+  - name: midday
+    start: "10:00"
+    end: "15:00"
   - name: afternoon
-    start: "12:00"
-    end: "18:00"
+    start: "15:00"
+    end: "17:00"
   - name: evening
-    start: "18:00"
+    start: "17:00"
     end: "24:00"
 
 recent_change:

internal/adapters/scriptorium/runner.go

@@ -3,12 +3,9 @@ package scriptorium
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
-	"os"
 	"os/exec"
-	"path/filepath"
 	"time"
 )
 
@@ -108,29 +105,20 @@ func (r Runner) Render(ctx context.Context, req RenderRequest) (*RenderResult, e
 	if req.DataPackagePath == "" {
 		return nil, fmt.Errorf("data package path is required")
 	}
-	binary := r.Binary
-	if binary == "" {
-		binary = "scriptorium"
-	}
-	commands := r.Commands
-	if commands == nil {
-		commands = ExecRunner{}
-	}
-	args := r.renderArgs(req)
-	commandResult, err := commands.Run(ctx, binary, args, r.Timeout)
+	execution, err := r.execute(ctx, r.renderArgs(req))
 	if err != nil {
 		return nil, fmt.Errorf("run scriptorium render: %w", err)
 	}
 	result := &RenderResult{
-		Command:         append([]string{binary}, args...),
-		Stdout:          string(commandResult.Stdout),
-		Stderr:          string(commandResult.Stderr),
-		StdoutTruncated: commandResult.StdoutTruncated,
-		StderrTruncated: commandResult.StderrTruncated,
-		ExitCode:        commandResult.ExitCode,
+		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,
 	}
-	if commandResult.ExitCode != 0 {
-		return result, fmt.Errorf("scriptorium render exited with code %d: %s", commandResult.ExitCode, result.Stderr)
+	if execution.result.ExitCode != 0 {
+		return result, fmt.Errorf("scriptorium render exited with code %d: %s", execution.result.ExitCode, result.Stderr)
 	}
 	return result, nil
 }
@@ -145,6 +133,32 @@ func (r Runner) Run(ctx context.Context, req RunRequest) (*RunResult, error) {
 	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,
+		OutputPath:      req.OutputPath,
+	}
+	if execution.result.ExitCode != 0 {
+		return result, fmt.Errorf("scriptorium run exited with code %d: %s", execution.result.ExitCode, result.Stderr)
+	}
+	return result, nil
+}
+
+type execution struct {
+	binary string
+	args   []string
+	result CommandResult
+}
+
+func (r Runner) execute(ctx context.Context, args []string) (execution, error) {
 	binary := r.Binary
 	if binary == "" {
 		binary = "scriptorium"
@@ -153,24 +167,15 @@ func (r Runner) Run(ctx context.Context, req RunRequest) (*RunResult, error) {
 	if commands == nil {
 		commands = ExecRunner{}
 	}
-	args := r.runArgs(req)
-	commandResult, err := commands.Run(ctx, binary, args, r.Timeout)
+	result, err := commands.Run(ctx, binary, args, r.Timeout)
 	if err != nil {
-		return nil, fmt.Errorf("run scriptorium: %w", err)
+		return execution{}, err
 	}
-	result := &RunResult{
-		Command:         append([]string{binary}, args...),
-		Stdout:          string(commandResult.Stdout),
-		Stderr:          string(commandResult.Stderr),
-		StdoutTruncated: commandResult.StdoutTruncated,
-		StderrTruncated: commandResult.StderrTruncated,
-		ExitCode:        commandResult.ExitCode,
-		OutputPath:      req.OutputPath,
-	}
-	if commandResult.ExitCode != 0 {
-		return result, fmt.Errorf("scriptorium run exited with code %d: %s", commandResult.ExitCode, result.Stderr)
-	}
-	return result, nil
+	return execution{binary: binary, args: args, result: result}, nil
+}
+
+func (e execution) argv() []string {
+	return append([]string{e.binary}, e.args...)
 }
 
 func (r Runner) renderArgs(req RenderRequest) []string {
@@ -207,37 +212,6 @@ func (r Runner) runArgs(req RunRequest) []string {
 	return args
 }
 
-func SaveRenderResult(path string, result *RenderResult) error {
-	if result == nil {
-		return fmt.Errorf("render result is required")
-	}
-	data, err := json.MarshalIndent(result, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal render result: %w", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return fmt.Errorf("create preflight directory %q: %w", filepath.Dir(path), err)
-	}
-	tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")
-	if err != nil {
-		return fmt.Errorf("create temporary preflight file: %w", err)
-	}
-	tmpName := tmp.Name()
-	defer os.Remove(tmpName)
-
-	if _, err := tmp.Write(data); err != nil {
-		tmp.Close()
-		return fmt.Errorf("write temporary preflight file: %w", err)
-	}
-	if err := tmp.Close(); err != nil {
-		return fmt.Errorf("close temporary preflight file: %w", err)
-	}
-	if err := os.Rename(tmpName, path); err != nil {
-		return fmt.Errorf("save preflight %q: %w", path, err)
-	}
-	return nil
-}
-
 type limitedBuffer struct {
 	data      []byte
 	limit     int

internal/adapters/weatherapi/client.go

@@ -11,14 +11,13 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"os"
 	"path"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
 
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/fileutil"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
 )
 
@@ -203,13 +202,18 @@ func (b *bundleBuilder) fetchNarrative(ctx context.Context) error {
 }
 
 func (b *bundleBuilder) fetchAlerts(ctx context.Context) error {
-	raw, source, err := b.client.fetch(ctx, "alerts", "/alerts/active", queryOptions{})
+	raw, source, err := b.client.fetch(ctx, "alerts", "/alerts/active", queryOptions{allowNull: true})
 	if err != nil {
 		return err
 	}
 	if raw == nil {
 		return b.handleMissing(&source, "active alerts data is missing", false)
 	}
+	if isJSONNull(raw) {
+		b.bundle.Alerts = &forecast.AlertRun{Raw: append(json.RawMessage(nil), raw...)}
+		b.addSource(source)
+		return nil
+	}
 	var alerts forecast.AlertRun
 	if err := decodeSource(raw, &alerts); err != nil {
 		return b.handleMalformed(&source, err, false)
@@ -302,6 +306,7 @@ func (c *Client) policyFor(source string) config.MissingSourcePolicy {
 type queryOptions struct {
 	precision bool
 	timezone  bool
+	allowNull bool
 }
 
 type envelope struct {
@@ -340,7 +345,7 @@ func (c *Client) fetch(ctx context.Context, sourceName string, endpoint string,
 		Query:     queryMap(reqURL.Query()),
 		FetchedAt: c.now(),
 	}
-	if len(env.Data) == 0 || bytes.Equal(bytes.TrimSpace(env.Data), []byte("null")) {
+	if len(env.Data) == 0 || (isJSONNull(env.Data) && !opts.allowNull) {
 		source.Missing = true
 		return nil, source, nil
 	}
@@ -352,6 +357,10 @@ func (c *Client) fetch(ctx context.Context, sourceName string, endpoint string,
 	return env.Data, source, nil
 }
 
+func isJSONNull(raw json.RawMessage) bool {
+	return bytes.Equal(bytes.TrimSpace(raw), []byte("null"))
+}
+
 func (c *Client) endpointURL(endpoint string, opts queryOptions) *url.URL {
 	reqURL := *c.baseURL
 	reqURL.Path = path.Join(c.baseURL.Path, endpoint)
@@ -398,29 +407,8 @@ func sourceHash(raw json.RawMessage) (string, error) {
 }
 
 func SaveBundle(path string, bundle *forecast.Bundle) error {
-	data, err := json.MarshalIndent(bundle, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal forecast bundle: %w", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return fmt.Errorf("create bundle directory %q: %w", filepath.Dir(path), err)
-	}
-	tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")
-	if err != nil {
-		return fmt.Errorf("create temporary bundle file: %w", err)
-	}
-	tmpName := tmp.Name()
-	defer os.Remove(tmpName)
-
-	if _, err := tmp.Write(data); err != nil {
-		tmp.Close()
-		return fmt.Errorf("write temporary bundle file: %w", err)
-	}
-	if err := tmp.Close(); err != nil {
-		return fmt.Errorf("close temporary bundle file: %w", err)
-	}
-	if err := os.Rename(tmpName, path); err != nil {
-		return fmt.Errorf("save bundle %q: %w", path, err)
+	if err := fileutil.WriteJSONAtomic(path, bundle); err != nil {
+		return fmt.Errorf("save bundle: %w", err)
 	}
 	return nil
 }

internal/adapters/weatherapi/client_test.go

@@ -43,6 +43,12 @@ func TestFetchBundleFromFixtures(t *testing.T) {
 	if bundle.Discussion == nil || len(bundle.Discussion.KeyMessages) != 2 {
 		t.Fatalf("Discussion = %#v, want key messages", bundle.Discussion)
 	}
+	if bundle.Discussion.ShortTerm == nil || bundle.Discussion.ShortTerm.Text != "A weak boundary may trigger isolated showers." {
+		t.Fatalf("Discussion.ShortTerm = %#v, want short-term AFD text", bundle.Discussion.ShortTerm)
+	}
+	if bundle.Discussion.LongTerm == nil || bundle.Discussion.LongTerm.Text != "Warmer temperatures and periodic rain chances continue into the weekend." {
+		t.Fatalf("Discussion.LongTerm = %#v, want long-term AFD text", bundle.Discussion.LongTerm)
+	}
 	if len(bundle.Sources) != 8 {
 		t.Fatalf("Sources length = %d, want 8", len(bundle.Sources))
 	}
@@ -72,7 +78,7 @@ func TestFetchBundleBuildsExpectedQueries(t *testing.T) {
 			t.Fatalf("request %q missing format=json or units=us", rawURL)
 		}
 		if strings.HasPrefix(rawURL, "/forecast/") {
-			if !strings.Contains(rawURL, "precision=1") || !strings.Contains(rawURL, "tz=Chicago") {
+			if !strings.Contains(rawURL, "precision=1") || !strings.Contains(rawURL, "tz=America%2FChicago") {
 				t.Fatalf("forecast request %q missing precision or tz", rawURL)
 			}
 		}
@@ -125,6 +131,36 @@ func TestRequiredHourlyForecast(t *testing.T) {
 	}
 }
 
+func TestNullAlertsMeansNoActiveAlerts(t *testing.T) {
+	server := fixtureServer(t, map[string]handlerOverride{
+		"/alerts/active": {status: http.StatusOK, body: `{"data": null}`},
+	}, nil)
+	client := newTestClient(t, server.URL+"/", nil)
+
+	bundle, err := client.FetchBundle(context.Background())
+	if err != nil {
+		t.Fatalf("FetchBundle() error = %v", err)
+	}
+	if bundle.Alerts == nil {
+		t.Fatal("Alerts = nil, want checked empty alert run")
+	}
+	if len(bundle.Alerts.Alerts) != 0 {
+		t.Fatalf("Alerts length = %d, want no active alerts", len(bundle.Alerts.Alerts))
+	}
+	source := sourceByName(t, bundle.Sources, "alerts")
+	if source.Missing {
+		t.Fatalf("alerts source Missing = true, want false")
+	}
+	if source.DataSHA256 == "" {
+		t.Fatal("alerts DataSHA256 is empty, want hash for explicit null payload")
+	}
+	for _, warning := range bundle.Warnings {
+		if warning.Source == "alerts" {
+			t.Fatalf("warnings = %#v, want no alerts warning", bundle.Warnings)
+		}
+	}
+}
+
 func TestMissingSourcePolicyWarnNoneError(t *testing.T) {
 	tests := []struct {
 		name       string

internal/adapters/weatherapi/testdata/discussion.json

@@ -9,8 +9,12 @@
       "Warmer temperatures this weekend."
     ],
     "shortTerm": {
-      "title": "Short Term",
-      "narrative": "A weak boundary may trigger isolated showers."
+      "qualifier": "(Through This Evening)",
+      "text": "A weak boundary may trigger isolated showers."
+    },
+    "longTerm": {
+      "qualifier": "(This Weekend)",
+      "text": "Warmer temperatures and periodic rain chances continue into the weekend."
     }
   }
 }

internal/app/app.go

@@ -4,9 +4,7 @@ package app
 import (
 	"context"
 	"fmt"
-	"os"
 	"path/filepath"
-	"strings"
 	"time"
 
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/scriptorium"
@@ -14,6 +12,7 @@ import (
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/changes"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/fileutil"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
@@ -68,8 +67,6 @@ type BriefingRequest struct {
 	OutputPath string
 }
 
-type DailyBriefingRequest = BriefingRequest
-
 type ReportRequest struct {
 	Config     config.Config
 	Resolved   report.Resolved
@@ -78,15 +75,11 @@ type ReportRequest struct {
 	Store      state.Store
 }
 
-type DailyReportRequest = ReportRequest
-
 type BriefingResult struct {
 	Package    briefing.Package
 	OutputPath string
 }
 
-type DailyBriefingResult = BriefingResult
-
 type ReportResult struct {
 	Briefing        briefing.Package
 	BriefingPath    string
@@ -103,8 +96,6 @@ type ReportResult struct {
 	RunResult       *scriptorium.RunResult
 }
 
-type DailyReportResult = ReportResult
-
 type BatchResult struct {
 	Batch      BatchKind           `json:"batch"`
 	StartedAt  time.Time           `json:"startedAt"`
@@ -157,7 +148,7 @@ func Generate(ctx context.Context, req GenerateRequest) error {
 	if err != nil {
 		return err
 	}
-	if isGeneratedReport(resolved.Definition.ID) {
+	if resolved.Definition.Generated {
 		_, err := GenerateReport(ctx, ReportRequest{
 			Config:     req.Config,
 			Resolved:   resolved,
@@ -200,7 +191,7 @@ func RunBatchDetailed(ctx context.Context, req BatchRequest) (*BatchResult, erro
 		startedAt := now
 		result := &BatchResult{Batch: req.Batch, StartedAt: startedAt}
 		for _, resolved := range resolvedReports {
-			if !isGeneratedReport(resolved.Definition.ID) {
+			if !resolved.Definition.Generated {
 				return nil, fmt.Errorf("run is not implemented")
 			}
 		}
@@ -257,19 +248,10 @@ func batchReportResult(resolved report.Resolved) BatchReportResult {
 }
 
 func batchOutputPath(outputDir string, definition report.Definition) string {
-	if outputDir == "" || definition.DefaultOutputName == "" {
+	if outputDir == "" || definition.BatchOutputName == "" {
 		return ""
 	}
-	name := strings.ReplaceAll(definition.DefaultOutputName, "_", "-")
-	return filepath.Join(outputDir, name)
-}
-
-func isGeneratedReport(id report.ID) bool {
-	return isDailyReport(id) || id == report.ThreeDay || id == report.Weekend || id == report.Storm
-}
-
-func isDailyReport(id report.ID) bool {
-	return id == report.DailyToday || id == report.DailyTomorrow
+	return filepath.Join(outputDir, definition.BatchOutputName)
 }
 
 func ResolveGenerate(req GenerateRequest, now time.Time) (report.Resolved, error) {
@@ -359,10 +341,6 @@ func FetchAndSaveBundle(ctx context.Context, req FetchBundleRequest) (*forecast.
 	return bundle, nil
 }
 
-func GenerateDailyBriefing(ctx context.Context, req DailyBriefingRequest) (*DailyBriefingResult, error) {
-	return GenerateBriefing(ctx, req)
-}
-
 func GenerateBriefing(ctx context.Context, req BriefingRequest) (*BriefingResult, error) {
 	bundle, err := FetchBundle(ctx, FetchBundleRequest{Config: req.Config})
 	if err != nil {
@@ -390,10 +368,6 @@ func GenerateBriefing(ctx context.Context, req BriefingRequest) (*BriefingResult
 	return &BriefingResult{Package: pkg, OutputPath: outputPath}, nil
 }
 
-func GenerateDailyReport(ctx context.Context, req DailyReportRequest) (*DailyReportResult, error) {
-	return GenerateReport(ctx, req)
-}
-
 func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, error) {
 	store := req.Store
 	if store == nil {
@@ -460,7 +434,7 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 	preflightPath := paths.Preflight
 	if renderResult != nil {
 		var err error
-		preflightPath, err = store.SavePreflight(ctx, req.Resolved, renderResult)
+		preflightPath, err = store.SavePreflight(ctx, req.Resolved, preflightArtifact(renderResult))
 		if err != nil {
 			return nil, err
 		}
@@ -490,7 +464,7 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 		OutputPath:      reportPath,
 	})
 	if runErr == nil && req.OutputPath != "" && req.OutputPath != reportPath {
-		if err := copyFileAtomic(reportPath, req.OutputPath); err != nil {
+		if err := fileutil.CopyFileAtomic(reportPath, req.OutputPath); err != nil {
 			return nil, err
 		}
 	}
@@ -524,10 +498,6 @@ func GenerateReport(ctx context.Context, req ReportRequest) (*ReportResult, erro
 	}, nil
 }
 
-func BuildDailyBriefing(req DailyBriefingRequest, bundle *forecast.Bundle) (briefing.Package, error) {
-	return BuildBriefing(req, bundle)
-}
-
 func BuildBriefing(req BriefingRequest, bundle *forecast.Bundle) (briefing.Package, error) {
 	location, err := timeutil.LoadLocation(req.Config.WeatherAPI.Timezone)
 	if err != nil {
@@ -552,6 +522,7 @@ func BuildBriefing(req BriefingRequest, bundle *forecast.Bundle) (briefing.Packa
 			Bundle:   bundle,
 			Units:    req.Config.WeatherAPI.Units,
 			Timezone: req.Config.WeatherAPI.Timezone,
+			Location: briefingLocation(req.Config),
 		}, summary)
 	case report.ThreeDay, report.Weekend:
 		summaries, err := forecast.BuildPeriodDailySummaries(bundle, req.Resolved.ValidPeriod, location, dayparts)
@@ -564,6 +535,7 @@ func BuildBriefing(req BriefingRequest, bundle *forecast.Bundle) (briefing.Packa
 				Bundle:   bundle,
 				Units:    req.Config.WeatherAPI.Units,
 				Timezone: req.Config.WeatherAPI.Timezone,
+				Location: briefingLocation(req.Config),
 			}, summaries)
 		}
 		return briefing.BuildThreeDay(briefing.BuildContext{
@@ -571,6 +543,7 @@ func BuildBriefing(req BriefingRequest, bundle *forecast.Bundle) (briefing.Packa
 			Bundle:   bundle,
 			Units:    req.Config.WeatherAPI.Units,
 			Timezone: req.Config.WeatherAPI.Timezone,
+			Location: briefingLocation(req.Config),
 		}, summaries)
 	case report.Storm:
 		return briefing.BuildStorm(briefing.BuildContext{
@@ -578,18 +551,28 @@ func BuildBriefing(req BriefingRequest, bundle *forecast.Bundle) (briefing.Packa
 			Bundle:   bundle,
 			Units:    req.Config.WeatherAPI.Units,
 			Timezone: req.Config.WeatherAPI.Timezone,
+			Location: briefingLocation(req.Config),
 		})
 	default:
 		return briefing.Package{}, fmt.Errorf("briefing is not implemented for report %q", req.Resolved.Definition.ID)
 	}
 }
 
-func defaultStore(cfg config.Config) (*state.FilesystemStore, error) {
-	return state.NewFilesystemStore(cfg.Workspace)
+func briefingLocation(cfg config.Config) *briefing.LocationContext {
+	location := briefing.LocationContext{
+		ID:       cfg.Location.ID,
+		Name:     cfg.Location.Name,
+		Region:   cfg.Location.Region,
+		Timezone: cfg.WeatherAPI.Timezone,
+	}
+	if location.ID == "" && location.Name == "" && location.Region == "" && location.Timezone == "" {
+		return nil
+	}
+	return &location
 }
 
-func dailyRecentChanges(ctx context.Context, store state.Store, priorSnapshot *state.PriorSnapshot, current briefing.Package, cfg config.RecentChangeConfig) ([]changes.Change, error) {
-	return recentChanges(ctx, store, priorSnapshot, current, cfg)
+func defaultStore(cfg config.Config) (*state.FilesystemStore, error) {
+	return state.NewFilesystemStore(cfg.Workspace)
 }
 
 func recentChanges(ctx context.Context, store state.Store, priorSnapshot *state.PriorSnapshot, current briefing.Package, cfg config.RecentChangeConfig) ([]changes.Change, error) {
@@ -618,29 +601,16 @@ func recentChanges(ctx context.Context, store state.Store, priorSnapshot *state.
 	}
 }
 
-func copyFileAtomic(source string, target string) error {
-	data, err := os.ReadFile(source)
-	if err != nil {
-		return fmt.Errorf("read rendered report %q: %w", source, err)
+func preflightArtifact(result *scriptorium.RenderResult) state.PreflightArtifact {
+	if result == nil {
+		return state.PreflightArtifact{}
 	}
-	if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
-		return fmt.Errorf("create report output directory %q: %w", filepath.Dir(target), err)
+	return state.PreflightArtifact{
+		Command:         append([]string(nil), result.Command...),
+		Stdout:          result.Stdout,
+		Stderr:          result.Stderr,
+		StdoutTruncated: result.StdoutTruncated,
+		StderrTruncated: result.StderrTruncated,
+		ExitCode:        result.ExitCode,
 	}
-	tmp, err := os.CreateTemp(filepath.Dir(target), "."+filepath.Base(target)+".*.tmp")
-	if err != nil {
-		return fmt.Errorf("create temporary report output file: %w", err)
-	}
-	tmpName := tmp.Name()
-	defer os.Remove(tmpName)
-	if _, err := tmp.Write(data); err != nil {
-		tmp.Close()
-		return fmt.Errorf("write temporary report output file: %w", err)
-	}
-	if err := tmp.Close(); err != nil {
-		return fmt.Errorf("close temporary report output file: %w", err)
-	}
-	if err := os.Rename(tmpName, target); err != nil {
-		return fmt.Errorf("save report output %q: %w", target, err)
-	}
-	return nil
 }

internal/app/app_test.go

@@ -2,6 +2,7 @@ package app
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"net/http"
 	"net/http/httptest"
@@ -33,7 +34,7 @@ func TestFetchAndSaveBundle(t *testing.T) {
 		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":[]}}`))
+			_, _ = 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."}}}`))
 		default:
 			http.NotFound(w, r)
 		}
@@ -70,11 +71,9 @@ func TestFetchAndSaveBundleRequiresOutputPath(t *testing.T) {
 	}
 }
 
-func TestGenerateDailyBriefingWritesArtifact(t *testing.T) {
+func TestGenerateBriefingWritesArtifact(t *testing.T) {
 	server := dailyBundleServer(t)
-	cfg := config.Defaults()
-	cfg.WeatherAPI.BaseURL = server.URL + "/"
-	cfg.WeatherAPI.Timezone = "America/Chicago"
+	cfg := dailyTestConfig(t, server)
 	resolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
 		Report: ReportDaily,
@@ -85,13 +84,13 @@ func TestGenerateDailyBriefingWritesArtifact(t *testing.T) {
 	}
 	path := filepath.Join(t.TempDir(), "daily.briefing.json")
 
-	result, err := GenerateDailyBriefing(context.Background(), DailyBriefingRequest{
+	result, err := GenerateBriefing(context.Background(), BriefingRequest{
 		Config:     cfg,
 		Resolved:   resolved,
 		OutputPath: path,
 	})
 	if err != nil {
-		t.Fatalf("GenerateDailyBriefing() error = %v", err)
+		t.Fatalf("GenerateBriefing() error = %v", err)
 	}
 	if result.OutputPath != path {
 		t.Fatalf("OutputPath = %q, want %q", result.OutputPath, path)
@@ -108,11 +107,9 @@ func TestGenerateDailyBriefingWritesArtifact(t *testing.T) {
 	}
 }
 
-func TestGenerateDailyBriefingDefaultPath(t *testing.T) {
+func TestGenerateBriefingDefaultPath(t *testing.T) {
 	server := dailyBundleServer(t)
-	cfg := config.Defaults()
-	cfg.WeatherAPI.BaseURL = server.URL + "/"
-	cfg.WeatherAPI.Timezone = "America/Chicago"
+	cfg := dailyTestConfig(t, server)
 	cfg.Workspace.Root = t.TempDir()
 	resolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
@@ -123,23 +120,21 @@ func TestGenerateDailyBriefingDefaultPath(t *testing.T) {
 		t.Fatalf("ResolveGenerate() error = %v", err)
 	}
 
-	result, err := GenerateDailyBriefing(context.Background(), DailyBriefingRequest{
+	result, err := GenerateBriefing(context.Background(), BriefingRequest{
 		Config:   cfg,
 		Resolved: resolved,
 	})
 	if err != nil {
-		t.Fatalf("GenerateDailyBriefing() error = %v", err)
+		t.Fatalf("GenerateBriefing() error = %v", err)
 	}
 	if !strings.HasSuffix(result.OutputPath, filepath.Join("snapshots", "daily", "2026-05-29", "20260529T100000.000000000Z_daily_today.briefing.json")) {
 		t.Fatalf("OutputPath = %q, want deterministic daily briefing path", result.OutputPath)
 	}
 }
 
-func TestGenerateDailyReportWritesReportAndPreflight(t *testing.T) {
+func TestGenerateReportWritesReportAndPreflight(t *testing.T) {
 	server := dailyBundleServer(t)
-	cfg := config.Defaults()
-	cfg.WeatherAPI.BaseURL = server.URL + "/"
-	cfg.WeatherAPI.Timezone = "America/Chicago"
+	cfg := dailyTestConfig(t, server)
 	cfg.Workspace.Root = t.TempDir()
 	resolved, err := ResolveGenerate(GenerateRequest{
 		Config: cfg,
@@ -165,14 +160,14 @@ func TestGenerateDailyReportWritesReportAndPreflight(t *testing.T) {
 	}
 	outputPath := filepath.Join(t.TempDir(), "daily.md")
 
-	result, err := GenerateDailyReport(context.Background(), DailyReportRequest{
+	result, err := GenerateReport(context.Background(), ReportRequest{
 		Config:     cfg,
 		Resolved:   resolved,
 		OutputPath: outputPath,
 		Renderer:   renderer,
 	})
 	if err != nil {
-		t.Fatalf("GenerateDailyReport() error = %v", err)
+		t.Fatalf("GenerateReport() error = %v", err)
 	}
 
 	if renderer.renderCalls != 1 {
@@ -193,14 +188,7 @@ func TestGenerateDailyReportWritesReportAndPreflight(t *testing.T) {
 	if renderer.runRequest.OutputPath != result.ReportPath {
 		t.Fatalf("run OutputPath = %q, want managed report path %q", renderer.runRequest.OutputPath, result.ReportPath)
 	}
-	for _, path := range []string{result.BriefingPath, result.DataPackagePath, result.PreflightPath, result.ReportPath, result.MetadataPath} {
-		if _, err := os.Stat(path); err != nil {
-			t.Fatalf("expected artifact %q: %v", path, err)
-		}
-	}
-	if _, err := os.Stat(outputPath); err != nil {
-		t.Fatalf("expected requested report output %q: %v", outputPath, err)
-	}
+	assertPathsExist(t, result.BriefingPath, result.DataPackagePath, result.PreflightPath, result.ReportPath, result.MetadataPath, outputPath)
 	data, err := os.ReadFile(result.DataPackagePath)
 	if err != nil {
 		t.Fatalf("read data package: %v", err)
@@ -208,6 +196,29 @@ func TestGenerateDailyReportWritesReportAndPreflight(t *testing.T) {
 	if !strings.Contains(string(data), `"recentChanges"`) || !strings.Contains(string(data), `data_package.v1`) {
 		t.Fatalf("data package missing expected content:\n%s", string(data))
 	}
+	var savedDataPackage struct {
+		Report struct {
+			CurrentLocalDate string `json:"currentLocalDate"`
+		} `json:"report"`
+		Briefing briefing.Package `json:"briefing"`
+	}
+	if err := json.Unmarshal(data, &savedDataPackage); err != nil {
+		t.Fatalf("decode data package: %v", err)
+	}
+	if savedDataPackage.Report.CurrentLocalDate != "2026-05-29" {
+		t.Fatalf("data package currentLocalDate = %q, want 2026-05-29", savedDataPackage.Report.CurrentLocalDate)
+	}
+	location := savedDataPackage.Briefing.Metadata.Location
+	if location == nil || location.ID != "home" || location.Name != "Brentwood" || location.Region != "St. Louis Metro" || location.Timezone != "America/Chicago" {
+		t.Fatalf("data package location = %#v, want configured prompt location", location)
+	}
+	current := savedDataPackage.Briefing.CurrentConditions
+	if current == nil || current.ConditionText != "Clear" || current.TemperatureF == nil || *current.TemperatureF != 75 {
+		t.Fatalf("data package current conditions = %#v, want current conditions", current)
+	}
+	if !strings.Contains(string(data), "Short-term AFD narrative for generated report.") || !strings.Contains(string(data), "Long-term AFD narrative for generated report.") {
+		t.Fatalf("data package missing AFD short/long-term discussion:\n%s", string(data))
+	}
 	preflight, err := os.ReadFile(result.PreflightPath)
 	if err != nil {
 		t.Fatalf("read preflight: %v", err)
@@ -236,7 +247,7 @@ func TestGenerateDailyReportWritesReportAndPreflight(t *testing.T) {
 	}
 }
 
-func TestGenerateDailyReportPersistsFailedPreflight(t *testing.T) {
+func TestGenerateReportPersistsFailedPreflight(t *testing.T) {
 	server := dailyBundleServer(t)
 	cfg := config.Defaults()
 	cfg.WeatherAPI.BaseURL = server.URL + "/"
@@ -259,13 +270,13 @@ func TestGenerateDailyReportPersistsFailedPreflight(t *testing.T) {
 		err: errors.New("scriptorium render exited with code 1: render failed"),
 	}
 
-	_, err = GenerateDailyReport(context.Background(), DailyReportRequest{
+	_, err = GenerateReport(context.Background(), ReportRequest{
 		Config:   cfg,
 		Resolved: resolved,
 		Renderer: renderer,
 	})
 	if err == nil {
-		t.Fatal("GenerateDailyReport() error = nil, want render error")
+		t.Fatal("GenerateReport() error = nil, want render error")
 	}
 	store, err := state.NewFilesystemStore(cfg.Workspace)
 	if err != nil {
@@ -291,7 +302,7 @@ func TestGenerateDailyReportPersistsFailedPreflight(t *testing.T) {
 	}
 }
 
-func TestGenerateDailyReportReturnsRunErrorAfterPreflight(t *testing.T) {
+func TestGenerateReportReturnsRunErrorAfterPreflight(t *testing.T) {
 	server := dailyBundleServer(t)
 	cfg := config.Defaults()
 	cfg.WeatherAPI.BaseURL = server.URL + "/"
@@ -315,13 +326,13 @@ func TestGenerateDailyReportReturnsRunErrorAfterPreflight(t *testing.T) {
 		runBody: "# Daily Report\n",
 	}
 
-	_, err = GenerateDailyReport(context.Background(), DailyReportRequest{
+	_, err = GenerateReport(context.Background(), ReportRequest{
 		Config:   cfg,
 		Resolved: resolved,
 		Renderer: renderer,
 	})
 	if err == nil {
-		t.Fatal("GenerateDailyReport() error = nil, want run error")
+		t.Fatal("GenerateReport() error = nil, want run error")
 	}
 	if renderer.renderCalls != 1 || renderer.runCalls != 1 {
 		t.Fatalf("calls render=%d run=%d, want one of each", renderer.renderCalls, renderer.runCalls)
@@ -342,7 +353,7 @@ func TestGenerateDailyReportReturnsRunErrorAfterPreflight(t *testing.T) {
 	}
 }
 
-func TestGenerateDailyReportIncludesRecentChangesFromPriorSnapshot(t *testing.T) {
+func TestGenerateReportIncludesRecentChangesFromPriorSnapshot(t *testing.T) {
 	server := dailyBundleServer(t)
 	cfg := config.Defaults()
 	cfg.WeatherAPI.BaseURL = server.URL + "/"
@@ -371,6 +382,7 @@ func TestGenerateDailyReportIncludesRecentChangesFromPriorSnapshot(t *testing.T)
 	}
 	_, err = store.SaveMetadata(context.Background(), state.BuildMetadata(priorResolved, priorBriefing, state.ArtifactPaths{
 		Briefing:       priorBriefingPath,
+		Metadata:       priorPaths.Metadata,
 		DataPackage:    priorPaths.DataPackage,
 		Preflight:      priorPaths.Preflight,
 		RenderedReport: priorPaths.RenderedReport,
@@ -393,14 +405,14 @@ func TestGenerateDailyReportIncludesRecentChangesFromPriorSnapshot(t *testing.T)
 		runBody:      "# Daily Report\n",
 	}
 
-	result, err := GenerateDailyReport(context.Background(), DailyReportRequest{
+	result, err := GenerateReport(context.Background(), ReportRequest{
 		Config:   cfg,
 		Resolved: currentResolved,
 		Renderer: renderer,
 		Store:    store,
 	})
 	if err != nil {
-		t.Fatalf("GenerateDailyReport() error = %v", err)
+		t.Fatalf("GenerateReport() error = %v", err)
 	}
 	if len(result.RecentChanges) == 0 {
 		t.Fatal("RecentChanges length = 0, want changes from prior snapshot")
@@ -433,13 +445,13 @@ func TestGenerateTomorrowReportUsesTomorrowBriefingDate(t *testing.T) {
 		runBody:      "# Tomorrow Planning Brief\n",
 	}
 
-	result, err := GenerateDailyReport(context.Background(), DailyReportRequest{
+	result, err := GenerateReport(context.Background(), ReportRequest{
 		Config:   cfg,
 		Resolved: resolved,
 		Renderer: renderer,
 	})
 	if err != nil {
-		t.Fatalf("GenerateDailyReport() error = %v", err)
+		t.Fatalf("GenerateReport() error = %v", err)
 	}
 
 	if result.Briefing.Metadata.ReportID != report.DailyTomorrow || result.Briefing.Metadata.Variant != "tomorrow" {
@@ -485,6 +497,7 @@ func TestTomorrowReportCanCompareAgainstPriorDailySnapshot(t *testing.T) {
 	}
 	_, err = store.SaveMetadata(context.Background(), state.BuildMetadata(priorResolved, priorBriefing, state.ArtifactPaths{
 		Briefing:       priorBriefingPath,
+		Metadata:       priorPaths.Metadata,
 		DataPackage:    priorPaths.DataPackage,
 		Preflight:      priorPaths.Preflight,
 		RenderedReport: priorPaths.RenderedReport,
@@ -506,14 +519,14 @@ func TestTomorrowReportCanCompareAgainstPriorDailySnapshot(t *testing.T) {
 		runBody:      "# Tomorrow Planning Brief\n",
 	}
 
-	result, err := GenerateDailyReport(context.Background(), DailyReportRequest{
+	result, err := GenerateReport(context.Background(), ReportRequest{
 		Config:   cfg,
 		Resolved: currentResolved,
 		Renderer: renderer,
 		Store:    store,
 	})
 	if err != nil {
-		t.Fatalf("GenerateDailyReport() error = %v", err)
+		t.Fatalf("GenerateReport() error = %v", err)
 	}
 	if result.PriorSnapshot == nil {
 		t.Fatal("PriorSnapshot = nil, want compatible prior daily snapshot")
@@ -551,6 +564,7 @@ func TestGenerateThreeDayReportWritesReportAndRecentChanges(t *testing.T) {
 	}
 	_, err = store.SaveMetadata(context.Background(), state.BuildMetadata(priorResolved, priorBriefing, state.ArtifactPaths{
 		Briefing:       priorBriefingPath,
+		Metadata:       priorPaths.Metadata,
 		DataPackage:    priorPaths.DataPackage,
 		Preflight:      priorPaths.Preflight,
 		RenderedReport: priorPaths.RenderedReport,
@@ -626,6 +640,7 @@ func TestGenerateWeekendReportWritesReportAndRecentChanges(t *testing.T) {
 	}
 	_, err = store.SaveMetadata(context.Background(), state.BuildMetadata(priorResolved, priorBriefing, state.ArtifactPaths{
 		Briefing:       priorBriefingPath,
+		Metadata:       priorPaths.Metadata,
 		DataPackage:    priorPaths.DataPackage,
 		Preflight:      priorPaths.Preflight,
 		RenderedReport: priorPaths.RenderedReport,
@@ -882,7 +897,7 @@ func dailyBundleServer(t *testing.T) *httptest.Server {
 		case "/observations":
 			_, _ = w.Write([]byte(`{"data":{"timestamp":"2026-05-29T14:00:00Z","conditionCode":3}}`))
 		case "/conditions/current":
-			_, _ = w.Write([]byte(`{"data":{"conditionText":"Clear"}}`))
+			_, _ = w.Write([]byte(`{"data":{"conditionText":"Clear","temperatureF":75,"relativeHumidityPercent":56,"windSpeedMph":8}}`))
 		case "/forecast/hourly":
 			_, _ = w.Write([]byte(`{"data":{"locationId":"test-grid","locationName":"Testville","issuedAt":"2026-05-29T10:30:00-05:00","product":"hourly","periods":[{"startTime":"2026-05-29T06:00:00-05:00","endTime":"2026-05-29T07:00:00-05:00","textDescription":"Showers and thunderstorms","temperatureF":66,"probabilityOfPrecipitationPercent":80,"windGustMph":32},{"startTime":"2026-05-30T06:00:00-05:00","endTime":"2026-05-30T07:00:00-05:00","textDescription":"Showers and thunderstorms","temperatureF":66,"probabilityOfPrecipitationPercent":80,"windGustMph":32}]}}`))
 		case "/forecast/narrative":
@@ -890,7 +905,7 @@ func dailyBundleServer(t *testing.T) *httptest.Server {
 		case "/alerts/active":
 			_, _ = w.Write([]byte(`{"data":{"alerts":[{"event":"Flood Watch","effective":"2026-05-29T05:00:00-05:00","expires":"2026-05-29T09:00:00-05:00"}]}}`))
 		case "/discussion":
-			_, _ = w.Write([]byte(`{"data":{"product":"discussion","issuedAt":"2026-05-29T09:25:00-05:00","keyMessages":["Storms are most likely during the morning."]}}`))
+			_, _ = w.Write([]byte(`{"data":{"product":"discussion","issuedAt":"2026-05-29T09:25:00-05:00","keyMessages":["Storms are most likely during the morning."],"shortTerm":{"qualifier":"(Short Term)","text":"Short-term AFD narrative for generated report."},"longTerm":{"qualifier":"(Long Term)","text":"Long-term AFD narrative for generated report."}}}`))
 		default:
 			http.NotFound(w, r)
 		}
@@ -1021,6 +1036,23 @@ func mustParse(value string) time.Time {
 	return parsed
 }
 
+func dailyTestConfig(t *testing.T, server *httptest.Server) config.Config {
+	t.Helper()
+	cfg := config.Defaults()
+	cfg.WeatherAPI.BaseURL = server.URL + "/"
+	cfg.WeatherAPI.Timezone = "America/Chicago"
+	return cfg
+}
+
+func assertPathsExist(t *testing.T, paths ...string) {
+	t.Helper()
+	for _, path := range paths {
+		if _, err := os.Stat(path); err != nil {
+			t.Fatalf("expected artifact %q: %v", path, err)
+		}
+	}
+}
+
 func priorDailyBriefing(resolved report.Resolved) briefing.Package {
 	low := 50.0
 	high := 58.0

internal/app/inspect.go

@@ -40,59 +40,44 @@ func InspectReports(ctx context.Context, req InspectReportsRequest) ([]state.Rep
 }
 
 func InspectMetadata(ctx context.Context, req InspectRunRequest) (state.Metadata, error) {
-	store, err := defaultStore(req.Config)
-	if err != nil {
-		return state.Metadata{}, err
-	}
-	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
-	return metadata, err
+	inspection, err := inspectRun(ctx, req)
+	return inspection.metadata, err
 }
 
 func InspectBriefing(ctx context.Context, req InspectRunRequest) (briefing.Package, error) {
-	store, err := defaultStore(req.Config)
+	inspection, err := inspectRun(ctx, req)
 	if err != nil {
 		return briefing.Package{}, err
 	}
-	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
-	if err != nil {
-		return briefing.Package{}, err
-	}
-	return store.LoadBriefing(ctx, metadata.BriefingPath)
+	return inspection.store.LoadBriefing(ctx, inspection.metadata.BriefingPath)
 }
 
 func InspectDataPackage(ctx context.Context, req InspectRunRequest) (promptinput.Package, error) {
-	store, err := defaultStore(req.Config)
+	inspection, err := inspectRun(ctx, req)
 	if err != nil {
 		return promptinput.Package{}, err
 	}
-	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
-	if err != nil {
-		return promptinput.Package{}, err
-	}
-	return store.LoadDataPackage(ctx, metadata.DataPackagePath)
+	return inspection.store.LoadDataPackage(ctx, inspection.metadata.DataPackagePath)
 }
 
 func InspectPriorSnapshot(ctx context.Context, req InspectRunRequest) (*state.PriorSnapshot, error) {
-	store, err := defaultStore(req.Config)
+	inspection, err := inspectRun(ctx, req)
 	if err != nil {
 		return nil, err
 	}
-	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
+	resolved, err := resolvedFromMetadata(inspection.metadata)
 	if err != nil {
 		return nil, err
 	}
-	resolved, err := resolvedFromMetadata(metadata)
-	if err != nil {
-		return nil, err
-	}
-	return store.FindPriorSnapshot(ctx, resolved)
+	return inspection.store.FindPriorSnapshot(ctx, resolved)
 }
 
 func InspectSources(ctx context.Context, req InspectRunRequest) (SourceInspection, error) {
-	metadata, err := InspectMetadata(ctx, req)
+	inspection, err := inspectRun(ctx, req)
 	if err != nil {
 		return SourceInspection{}, err
 	}
+	metadata := inspection.metadata
 	return SourceInspection{
 		RunID:          metadata.RunID,
 		ReportID:       metadata.ReportID,
@@ -102,6 +87,23 @@ func InspectSources(ctx context.Context, req InspectRunRequest) (SourceInspectio
 	}, nil
 }
 
+type runInspection struct {
+	store    *state.FilesystemStore
+	metadata state.Metadata
+}
+
+func inspectRun(ctx context.Context, req InspectRunRequest) (runInspection, error) {
+	store, err := defaultStore(req.Config)
+	if err != nil {
+		return runInspection{}, err
+	}
+	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
+	if err != nil {
+		return runInspection{}, err
+	}
+	return runInspection{store: store, metadata: metadata}, nil
+}
+
 func resolvedFromMetadata(metadata state.Metadata) (report.Resolved, error) {
 	definition, err := report.DefaultRegistry().Lookup(metadata.ReportID)
 	if err != nil {

internal/briefing/daily.go

@@ -68,19 +68,18 @@ func BuildDaily(ctx BuildContext, summary *forecast.DailySummary) (Package, erro
 	if summary == nil {
 		return Package{}, fmt.Errorf("daily forecast summary is required")
 	}
-	pkg := Package{
-		Metadata: BuildMetadata(ctx),
-		Daily: &Daily{
-			BottomLine:          buildBottomLine(summary),
-			Dayparts:            summary.Dayparts,
-			RelevantAlerts:      summary.AlertOverlaps,
-			OutdoorWindows:      buildOutdoorWindows(summary.Dayparts),
-			NarrativePeriods:    summary.NarrativePeriods,
-			Discussion:          buildDiscussion(summary.Discussion),
-			WeatherStory:        buildWeatherStory(ctx.Bundle),
-			ForecastSummaryDate: summary.Date,
-		},
+	pkg := buildPackage(ctx)
+	pkg.Daily = &Daily{
+		BottomLine:          buildBottomLine(summary),
+		Dayparts:            summary.Dayparts,
+		RelevantAlerts:      summary.AlertOverlaps,
+		OutdoorWindows:      buildOutdoorWindows(summary.Dayparts),
+		NarrativePeriods:    summary.NarrativePeriods,
+		Discussion:          buildDiscussion(summary.Discussion),
+		WeatherStory:        buildWeatherStory(ctx.Bundle),
+		ForecastSummaryDate: summary.Date,
 	}
+	setRelevantAlertCount(&pkg.Metadata, len(summary.AlertOverlaps))
 	if ctx.Resolved.Definition.ID == report.DailyTomorrow {
 		pkg.Daily.Planning = buildTomorrowPlanning(summary)
 	}
@@ -176,9 +175,6 @@ func readinessNotes(daypart forecast.DaypartSummary) []string {
 	if daypart.PeakWindGust != nil && daypart.PeakWindGust.Value >= 30 {
 		notes = append(notes, fmt.Sprintf("Morning gusts may reach %.0f mph.", daypart.PeakWindGust.Value))
 	}
-	if daypart.Indicators.Thunder {
-		notes = append(notes, "Morning thunder could affect departure timing.")
-	}
 	if daypart.Indicators.Snow || daypart.Indicators.Ice {
 		notes = append(notes, "Morning wintry weather could affect surfaces and travel.")
 	}
@@ -203,9 +199,6 @@ func concernNotes(daypart forecast.DaypartSummary) []string {
 	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.Thunder {
-		notes = append(notes, prefix+" thunder may disrupt outdoor plans.")
-	}
 	if daypart.Indicators.Snow || daypart.Indicators.Ice {
 		notes = append(notes, prefix+" wintry weather may affect travel.")
 	}
@@ -229,9 +222,6 @@ func overnightWatchNotes(daypart forecast.DaypartSummary) []string {
 	if daypart.PeakWindGust != nil && daypart.PeakWindGust.Value >= 30 {
 		notes = append(notes, fmt.Sprintf("Overnight gusts may reach %.0f mph before morning plans begin.", daypart.PeakWindGust.Value))
 	}
-	if daypart.Indicators.Thunder {
-		notes = append(notes, "Overnight storms could change morning impacts.")
-	}
 	if daypart.Indicators.Snow || daypart.Indicators.Ice {
 		notes = append(notes, "Overnight wintry weather could leave morning travel impacts.")
 	}
@@ -259,10 +249,10 @@ func buildDiscussion(discussion *forecast.Discussion) DiscussionContext {
 		KeyMessages: discussion.KeyMessages,
 	}
 	if discussion.ShortTerm != nil {
-		ctx.ShortTerm = discussion.ShortTerm.Narrative
+		ctx.ShortTerm = discussion.ShortTerm.Text
 	}
 	if discussion.LongTerm != nil {
-		ctx.LongTerm = discussion.LongTerm.Narrative
+		ctx.LongTerm = discussion.LongTerm.Text
 	}
 	return ctx
 }
@@ -293,10 +283,6 @@ func scoreOutdoorWindow(daypart forecast.DaypartSummary) OutdoorWindow {
 		score += float64(len(daypart.AlertOverlaps)) * 100
 		reasons = append(reasons, "alert overlap")
 	}
-	if daypart.Indicators.Thunder {
-		score += 75
-		reasons = append(reasons, "thunder risk")
-	}
 	if daypart.Indicators.Heat || daypart.Indicators.Cold {
 		score += 25
 		if daypart.Indicators.Heat {
@@ -334,9 +320,6 @@ func bottomLineText(conditions []string, hazards []string) string {
 
 func hazardsForIndicators(indicators forecast.Indicators) []string {
 	var hazards []string
-	if indicators.Thunder {
-		hazards = append(hazards, "thunder")
-	}
 	if indicators.Snow {
 		hazards = append(hazards, "snow")
 	}

internal/briefing/daily_test.go

@@ -15,6 +15,19 @@ import (
 
 func TestDailyBriefingFromRepresentativeFixture(t *testing.T) {
 	bundle := loadBundleFixture(t)
+	currentIsDay := true
+	currentTemp := 75.9
+	currentFeelsLike := 76.1
+	currentHumidity := 56.0
+	currentWind := 10.7
+	bundle.Current = &forecast.Current{
+		ConditionText:           "Partly cloudy",
+		IsDay:                   &currentIsDay,
+		TemperatureF:            &currentTemp,
+		ApparentTemperatureF:    &currentFeelsLike,
+		RelativeHumidityPercent: &currentHumidity,
+		WindSpeedMph:            &currentWind,
+	}
 	bundle.Sources[0].DataSHA256 = "abc123"
 	bundle.Warnings = []forecast.SourceWarning{{Source: "daily", Code: "missing_source", Severity: "warning"}}
 	location := mustLocation(t)
@@ -29,6 +42,12 @@ func TestDailyBriefingFromRepresentativeFixture(t *testing.T) {
 		Bundle:   bundle,
 		Units:    "us",
 		Timezone: "America/Chicago",
+		Location: &LocationContext{
+			ID:       "home",
+			Name:     "Brentwood",
+			Region:   "St. Louis Metro",
+			Timezone: "America/Chicago",
+		},
 	}, summary)
 	if err != nil {
 		t.Fatalf("BuildDaily() error = %v", err)
@@ -46,6 +65,12 @@ func TestDailyBriefingFromRepresentativeFixture(t *testing.T) {
 	if pkg.Metadata.Units != "us" || pkg.Metadata.Timezone != "America/Chicago" {
 		t.Fatalf("metadata units/timezone = %q/%q", pkg.Metadata.Units, pkg.Metadata.Timezone)
 	}
+	if pkg.Metadata.Location == nil || pkg.Metadata.Location.ID != "home" || pkg.Metadata.Location.Name != "Brentwood" || pkg.Metadata.Location.Region != "St. Louis Metro" || pkg.Metadata.Location.Timezone != "America/Chicago" {
+		t.Fatalf("metadata location = %#v, want configured prompt location", pkg.Metadata.Location)
+	}
+	if pkg.CurrentConditions == nil || pkg.CurrentConditions.ConditionText != "Partly cloudy" || pkg.CurrentConditions.TemperatureF == nil || *pkg.CurrentConditions.TemperatureF != currentTemp || pkg.CurrentConditions.RelativeHumidityPercent == nil || *pkg.CurrentConditions.RelativeHumidityPercent != currentHumidity {
+		t.Fatalf("CurrentConditions = %#v, want current conditions from bundle", pkg.CurrentConditions)
+	}
 	if len(pkg.Metadata.Sources) != 1 || pkg.Metadata.Sources[0].DataSHA256 != "abc123" {
 		t.Fatalf("Sources = %#v, want source hash", pkg.Metadata.Sources)
 	}
@@ -55,8 +80,8 @@ func TestDailyBriefingFromRepresentativeFixture(t *testing.T) {
 	if pkg.Daily == nil {
 		t.Fatal("Daily = nil")
 	}
-	if len(pkg.Daily.Dayparts) != 4 {
-		t.Fatalf("Dayparts length = %d, want 4", len(pkg.Daily.Dayparts))
+	if len(pkg.Daily.Dayparts) != 5 {
+		t.Fatalf("Dayparts length = %d, want 5", len(pkg.Daily.Dayparts))
 	}
 	if len(pkg.Daily.RelevantAlerts) != 1 {
 		t.Fatalf("RelevantAlerts length = %d, want 1", len(pkg.Daily.RelevantAlerts))
@@ -67,6 +92,12 @@ func TestDailyBriefingFromRepresentativeFixture(t *testing.T) {
 	if len(pkg.Daily.Discussion.KeyMessages) != 1 {
 		t.Fatalf("Discussion key messages length = %d, want 1", len(pkg.Daily.Discussion.KeyMessages))
 	}
+	if pkg.Daily.Discussion.ShortTerm != "Morning showers taper as a weak boundary shifts east." {
+		t.Fatalf("Discussion.ShortTerm = %q, want short-term AFD narrative", pkg.Daily.Discussion.ShortTerm)
+	}
+	if pkg.Daily.Discussion.LongTerm != "Warmer and more humid conditions return with periodic rain chances." {
+		t.Fatalf("Discussion.LongTerm = %q, want long-term AFD narrative", pkg.Daily.Discussion.LongTerm)
+	}
 	if pkg.Daily.OutdoorWindows.Best == nil || pkg.Daily.OutdoorWindows.Worst == nil {
 		t.Fatalf("OutdoorWindows = %#v, want best and worst", pkg.Daily.OutdoorWindows)
 	}
@@ -85,7 +116,13 @@ func TestDailyBriefingQuietWeather(t *testing.T) {
 		Hourly: &forecast.ForecastRun{Periods: []forecast.ForecastPeriod{
 			quietHour("2026-05-29T09:00:00-05:00", "2026-05-29T10:00:00-05:00", 72),
 		}},
-		Sources: []forecast.Source{{Name: "hourly", FetchedAt: time.Now()}},
+		Alerts: &forecast.AlertRun{},
+		Sources: []forecast.Source{
+			{Name: "hourly", FetchedAt: time.Now()},
+			{Name: "alerts", Endpoint: "/alerts/active", FetchedAt: time.Now()},
+			{Name: "current", Endpoint: "/conditions/current", FetchedAt: time.Now(), Missing: true},
+		},
+		Warnings: []forecast.SourceWarning{{Source: "current", Code: "missing_source", Severity: "warning"}},
 	}
 	summary, err := forecast.BuildDailySummary(bundle, resolved.ValidPeriod.Start, location, defaultDayparts())
 	if err != nil {
@@ -98,9 +135,28 @@ func TestDailyBriefingQuietWeather(t *testing.T) {
 	if pkg.Daily.BottomLine.Summary != "Conditions: Clear." {
 		t.Fatalf("BottomLine summary = %q, want clear conditions", pkg.Daily.BottomLine.Summary)
 	}
+	if pkg.CurrentConditions != nil {
+		t.Fatalf("CurrentConditions = %#v, want nil when current conditions are missing", pkg.CurrentConditions)
+	}
+	if len(pkg.Metadata.SourceWarnings) != 1 || pkg.Metadata.SourceWarnings[0].Source != "current" {
+		t.Fatalf("SourceWarnings = %#v, want current missing-source warning", pkg.Metadata.SourceWarnings)
+	}
 	if len(pkg.Daily.RelevantAlerts) != 0 {
 		t.Fatalf("RelevantAlerts length = %d, want 0", len(pkg.Daily.RelevantAlerts))
 	}
+	if pkg.Metadata.Alerts == nil {
+		t.Fatal("Metadata.Alerts = nil, want checked no-active-alerts status")
+	}
+	if !pkg.Metadata.Alerts.Checked || pkg.Metadata.Alerts.ActiveCount != 0 || pkg.Metadata.Alerts.RelevantCount != 0 || pkg.Metadata.Alerts.Missing {
+		t.Fatalf("Metadata.Alerts = %#v, want checked no-active-alerts status", pkg.Metadata.Alerts)
+	}
+	data, err := json.Marshal(pkg.Metadata.Alerts)
+	if err != nil {
+		t.Fatalf("marshal alert metadata: %v", err)
+	}
+	if strings.Contains(string(data), `"missing"`) {
+		t.Fatalf("alert metadata includes missing for checked empty alerts:\n%s", string(data))
+	}
 }
 
 func TestDailyBriefingAlertExclusion(t *testing.T) {
@@ -163,7 +219,7 @@ func TestTomorrowBriefingIncludesPlanningInputs(t *testing.T) {
 					Value: wind,
 					Time:  mustParse("2026-05-30T09:00:00-05:00"),
 				},
-				Indicators: forecast.Indicators{Thunder: true},
+				Indicators: forecast.Indicators{Snow: true},
 			},
 		},
 	}
@@ -237,9 +293,10 @@ func mustResolveDaily(t *testing.T, location *time.Location) report.Resolved {
 func defaultDayparts() []forecast.DaypartDefinition {
 	return []forecast.DaypartDefinition{
 		{Name: "overnight", Start: "00:00", End: "06:00"},
-		{Name: "morning", Start: "06:00", End: "12:00"},
-		{Name: "afternoon", Start: "12:00", End: "18:00"},
-		{Name: "evening", Start: "18:00", End: "24:00"},
+		{Name: "morning", Start: "06:00", End: "10:00"},
+		{Name: "midday", Start: "10:00", End: "15:00"},
+		{Name: "afternoon", Start: "15:00", End: "17:00"},
+		{Name: "evening", Start: "17:00", End: "24:00"},
 	}
 }
 

internal/briefing/package.go

@@ -2,12 +2,10 @@
 package briefing
 
 import (
-	"encoding/json"
 	"fmt"
-	"os"
-	"path/filepath"
 	"time"
 
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/fileutil"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
@@ -16,11 +14,12 @@ import (
 const SchemaVersion = "weatherreporter.briefing.v1"
 
 type Package struct {
-	Metadata Metadata  `json:"metadata"`
-	Daily    *Daily    `json:"daily,omitempty"`
-	ThreeDay *ThreeDay `json:"threeDay,omitempty"`
-	Weekend  *Weekend  `json:"weekend,omitempty"`
-	Storm    *Storm    `json:"storm,omitempty"`
+	Metadata          Metadata                  `json:"metadata"`
+	CurrentConditions *CurrentConditionsContext `json:"currentConditions,omitempty"`
+	Daily             *Daily                    `json:"daily,omitempty"`
+	ThreeDay          *ThreeDay                 `json:"threeDay,omitempty"`
+	Weekend           *Weekend                  `json:"weekend,omitempty"`
+	Storm             *Storm                    `json:"storm,omitempty"`
 }
 
 type Metadata struct {
@@ -33,10 +32,34 @@ type Metadata struct {
 	Units            string                   `json:"units"`
 	Timezone         string                   `json:"timezone"`
 	ValidPeriod      timeutil.Period          `json:"validPeriod"`
+	Location         *LocationContext         `json:"location,omitempty"`
 	SourceLocationID string                   `json:"sourceLocationId,omitempty"`
 	SourceLocation   string                   `json:"sourceLocation,omitempty"`
 	Sources          []SourceMetadata         `json:"sources,omitempty"`
 	SourceWarnings   []forecast.SourceWarning `json:"sourceWarnings,omitempty"`
+	Alerts           *AlertStatus             `json:"alerts,omitempty"`
+}
+
+type LocationContext struct {
+	ID       string `json:"id,omitempty"`
+	Name     string `json:"name,omitempty"`
+	Region   string `json:"region,omitempty"`
+	Timezone string `json:"timezone,omitempty"`
+}
+
+type CurrentConditionsContext struct {
+	ConditionText           string   `json:"conditionText,omitempty"`
+	IsDay                   *bool    `json:"isDay,omitempty"`
+	TemperatureC            *float64 `json:"temperatureC,omitempty"`
+	TemperatureF            *float64 `json:"temperatureF,omitempty"`
+	ApparentTemperatureC    *float64 `json:"apparentTemperatureC,omitempty"`
+	ApparentTemperatureF    *float64 `json:"apparentTemperatureF,omitempty"`
+	DewpointC               *float64 `json:"dewpointC,omitempty"`
+	DewpointF               *float64 `json:"dewpointF,omitempty"`
+	RelativeHumidityPercent *float64 `json:"relativeHumidityPercent,omitempty"`
+	WindSpeedKmh            *float64 `json:"windSpeedKmh,omitempty"`
+	WindSpeedMph            *float64 `json:"windSpeedMph,omitempty"`
+	WindDirectionDegrees    *float64 `json:"windDirectionDegrees,omitempty"`
 }
 
 type SourceMetadata struct {
@@ -50,11 +73,19 @@ type SourceMetadata struct {
 	Warnings   []forecast.SourceWarning `json:"warnings,omitempty"`
 }
 
+type AlertStatus struct {
+	Checked       bool `json:"checked"`
+	ActiveCount   int  `json:"activeCount"`
+	RelevantCount int  `json:"relevantCount"`
+	Missing       bool `json:"missing,omitempty"`
+}
+
 type BuildContext struct {
 	Resolved report.Resolved
 	Bundle   *forecast.Bundle
 	Units    string
 	Timezone string
+	Location *LocationContext
 }
 
 func BuildMetadata(ctx BuildContext) Metadata {
@@ -70,37 +101,85 @@ func BuildMetadata(ctx BuildContext) Metadata {
 		Units:            ctx.Units,
 		Timezone:         ctx.Timezone,
 		ValidPeriod:      metadata.ValidPeriod,
+		Location:         copyLocation(ctx.Location),
 		SourceLocationID: sourceLocationID,
 		SourceLocation:   sourceLocation,
 		Sources:          sourceMetadata(ctx.Bundle),
 		SourceWarnings:   sourceWarnings(ctx.Bundle),
+		Alerts:           alertStatus(ctx.Bundle),
 	}
 }
 
-func Save(path string, pkg Package) error {
-	data, err := json.MarshalIndent(pkg, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal briefing package: %w", err)
+func buildPackage(ctx BuildContext) Package {
+	return Package{
+		Metadata:          BuildMetadata(ctx),
+		CurrentConditions: currentConditions(ctx.Bundle),
 	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return fmt.Errorf("create briefing directory %q: %w", filepath.Dir(path), err)
-	}
-	tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")
-	if err != nil {
-		return fmt.Errorf("create temporary briefing file: %w", err)
-	}
-	tmpName := tmp.Name()
-	defer os.Remove(tmpName)
+}
 
-	if _, err := tmp.Write(data); err != nil {
-		tmp.Close()
-		return fmt.Errorf("write temporary briefing file: %w", err)
+func copyLocation(location *LocationContext) *LocationContext {
+	if location == nil {
+		return nil
 	}
-	if err := tmp.Close(); err != nil {
-		return fmt.Errorf("close temporary briefing file: %w", err)
+	copied := *location
+	return &copied
+}
+
+func currentConditions(bundle *forecast.Bundle) *CurrentConditionsContext {
+	if bundle == nil || bundle.Current == nil {
+		return nil
 	}
-	if err := os.Rename(tmpName, path); err != nil {
-		return fmt.Errorf("save briefing %q: %w", path, err)
+	current := bundle.Current
+	context := CurrentConditionsContext{
+		ConditionText:           current.ConditionText,
+		IsDay:                   copyBool(current.IsDay),
+		TemperatureC:            copyFloat(current.TemperatureC),
+		TemperatureF:            copyFloat(current.TemperatureF),
+		ApparentTemperatureC:    copyFloat(current.ApparentTemperatureC),
+		ApparentTemperatureF:    copyFloat(current.ApparentTemperatureF),
+		DewpointC:               copyFloat(current.DewpointC),
+		DewpointF:               copyFloat(current.DewpointF),
+		RelativeHumidityPercent: copyFloat(current.RelativeHumidityPercent),
+		WindSpeedKmh:            copyFloat(current.WindSpeedKmh),
+		WindSpeedMph:            copyFloat(current.WindSpeedMph),
+		WindDirectionDegrees:    copyFloat(current.WindDirectionDegrees),
+	}
+	if context.ConditionText == "" &&
+		context.IsDay == nil &&
+		context.TemperatureC == nil &&
+		context.TemperatureF == nil &&
+		context.ApparentTemperatureC == nil &&
+		context.ApparentTemperatureF == nil &&
+		context.DewpointC == nil &&
+		context.DewpointF == nil &&
+		context.RelativeHumidityPercent == nil &&
+		context.WindSpeedKmh == nil &&
+		context.WindSpeedMph == nil &&
+		context.WindDirectionDegrees == nil {
+		return nil
+	}
+	return &context
+}
+
+func copyBool(value *bool) *bool {
+	if value == nil {
+		return nil
+	}
+	copied := *value
+	return &copied
+}
+
+func copyFloat(value *float64) *float64 {
+	if value == nil {
+		return nil
+	}
+	copied := *value
+	return &copied
+}
+
+func Save(path string, pkg Package) error {
+	if err := fileutil.WriteJSONAtomic(path, pkg); err != nil {
+		return fmt.Errorf("save briefing package: %w", err)
 	}
 	return nil
 }
@@ -147,6 +226,37 @@ func sourceWarnings(bundle *forecast.Bundle) []forecast.SourceWarning {
 	return bundle.Warnings
 }
 
+func alertStatus(bundle *forecast.Bundle) *AlertStatus {
+	if bundle == nil {
+		return nil
+	}
+	status := &AlertStatus{}
+	if bundle.Alerts != nil {
+		status.Checked = true
+		status.ActiveCount = len(bundle.Alerts.Alerts)
+	}
+	for _, source := range bundle.Sources {
+		if source.Name == "alerts" && source.Missing {
+			status.Missing = true
+			break
+		}
+	}
+	if !status.Checked && !status.Missing {
+		return nil
+	}
+	return status
+}
+
+func setRelevantAlertCount(metadata *Metadata, count int) {
+	if metadata.Alerts == nil {
+		if count == 0 {
+			return
+		}
+		metadata.Alerts = &AlertStatus{}
+	}
+	metadata.Alerts.RelevantCount = count
+}
+
 func variantForReport(id report.ID) string {
 	switch id {
 	case report.DailyToday:

internal/briefing/storm.go

@@ -56,10 +56,10 @@ func BuildStorm(ctx BuildContext) (Package, error) {
 		Discussion:          buildDiscussion(ctx.Bundle.Discussion),
 		WeatherStory:        buildWeatherStory(ctx.Bundle),
 	}
-	return Package{
-		Metadata: BuildMetadata(ctx),
-		Storm:    storm,
-	}, nil
+	pkg := buildPackage(ctx)
+	pkg.Storm = storm
+	setRelevantAlertCount(&pkg.Metadata, len(alerts))
+	return pkg, nil
 }
 
 func stormHeadlines(alerts []forecast.AlertOverlap) []string {
@@ -139,9 +139,6 @@ func reasonableWorstCase(alerts []forecast.AlertOverlap, summary forecast.Daypar
 			items = appendUnique(items, "Alert scenario to consider: "+label+".")
 		}
 	}
-	if summary.Indicators.Thunder {
-		items = appendUnique(items, "Thunderstorm timing or intensity could be more disruptive than the baseline forecast.")
-	}
 	if summary.Indicators.Wind {
 		items = appendUnique(items, "Wind impacts could be higher where stronger gusts occur.")
 	}
@@ -161,7 +158,7 @@ func stormConfidenceInputs(bundle *forecast.Bundle) []string {
 	}
 	if bundle.Discussion != nil {
 		items = appendUnique(items, bundle.Discussion.KeyMessages...)
-		if bundle.Discussion.ShortTerm != nil && bundle.Discussion.ShortTerm.Narrative != "" {
+		if bundle.Discussion.ShortTerm != nil && bundle.Discussion.ShortTerm.Text != "" {
 			items = appendUnique(items, "Short-term discussion is available for confidence context.")
 		}
 	}

internal/briefing/storm_test.go

@@ -44,7 +44,12 @@ func TestStormBriefingWithActiveAlert(t *testing.T) {
 		Alerts: &forecast.AlertRun{Alerts: []json.RawMessage{
 			json.RawMessage(`{"event":"Severe Thunderstorm Warning","headline":"Severe storms near Testville","severity":"Severe","effective":"2026-05-29T06:30:00-05:00","expires":"2026-05-29T08:30:00-05:00"}`),
 		}},
-		Discussion:   &forecast.Discussion{Product: "discussion", KeyMessages: []string{"Storms may intensify quickly."}},
+		Discussion: &forecast.Discussion{
+			Product:     "discussion",
+			KeyMessages: []string{"Storms may intensify quickly."},
+			ShortTerm:   &forecast.DiscussionSection{Text: "Short-term storm coverage peaks this morning."},
+			LongTerm:    &forecast.DiscussionSection{Text: "Long-term pattern stays unsettled after the event."},
+		},
 		WeatherStory: &forecast.WeatherStory{Raw: json.RawMessage(`{"headline":"Storm risk"}`)},
 		Sources:      []forecast.Source{{Name: "hourly", FetchedAt: time.Now()}},
 	}
@@ -75,6 +80,12 @@ func TestStormBriefingWithActiveAlert(t *testing.T) {
 	if pkg.Storm.WeatherStory == nil {
 		t.Fatal("WeatherStory = nil, want available story context")
 	}
+	if pkg.Storm.Discussion.ShortTerm != "Short-term storm coverage peaks this morning." {
+		t.Fatalf("Discussion.ShortTerm = %q, want short-term AFD narrative", pkg.Storm.Discussion.ShortTerm)
+	}
+	if pkg.Storm.Discussion.LongTerm != "Long-term pattern stays unsettled after the event." {
+		t.Fatalf("Discussion.LongTerm = %q, want long-term AFD narrative", pkg.Storm.Discussion.LongTerm)
+	}
 	if len(pkg.Storm.WhatToWatchNext) == 0 {
 		t.Fatal("WhatToWatchNext length = 0, want watch inputs")
 	}

internal/briefing/three_day.go

@@ -37,18 +37,17 @@ func BuildThreeDay(ctx BuildContext, summaries []forecast.DailySummary) (Package
 	if len(summaries) == 0 {
 		return Package{}, fmt.Errorf("3-day forecast summaries are required")
 	}
-	pkg := Package{
-		Metadata: BuildMetadata(ctx),
-		ThreeDay: &ThreeDay{
-			Discussion:   buildDiscussion(summaries[0].Discussion),
-			WeatherStory: buildWeatherStory(ctx.Bundle),
-		},
+	pkg := buildPackage(ctx)
+	pkg.ThreeDay = &ThreeDay{
+		Discussion:   buildDiscussion(summaries[0].Discussion),
+		WeatherStory: buildWeatherStory(ctx.Bundle),
 	}
 	for _, summary := range summaries {
 		day := buildOutlookDay(summary)
 		pkg.ThreeDay.Days = append(pkg.ThreeDay.Days, day)
 	}
 	pkg.ThreeDay.RelevantAlerts = collectOutlookAlerts(pkg.ThreeDay.Days)
+	setRelevantAlertCount(&pkg.Metadata, len(pkg.ThreeDay.RelevantAlerts))
 	return pkg, nil
 }
 

internal/briefing/three_day_test.go

@@ -39,11 +39,16 @@ func TestThreeDayBriefingBuildsOutlookDays(t *testing.T) {
 						Value: gust,
 						Time:  mustParse("2026-05-29T10:00:00-05:00"),
 					},
-					Indicators: forecast.Indicators{Thunder: true, Wind: true},
+					Indicators: forecast.Indicators{Wind: true},
 				},
 			},
 			AlertOverlaps: []forecast.AlertOverlap{{Event: "Flood Watch"}},
-			Discussion:    &forecast.Discussion{Product: "discussion", KeyMessages: []string{"Unsettled stretch."}},
+			Discussion: &forecast.Discussion{
+				Product:     "discussion",
+				KeyMessages: []string{"Unsettled stretch."},
+				ShortTerm:   &forecast.DiscussionSection{Text: "Short-term rain chances remain focused today."},
+				LongTerm:    &forecast.DiscussionSection{Text: "Long-term warmth builds into the weekend."},
+			},
 		},
 		{
 			Date: "2026-05-30",
@@ -74,10 +79,16 @@ func TestThreeDayBriefingBuildsOutlookDays(t *testing.T) {
 		t.Fatalf("Days length = %d, want 2", len(pkg.ThreeDay.Days))
 	}
 	first := pkg.ThreeDay.Days[0]
-	if !strings.Contains(first.OverallCharacter, "Showers") || !strings.Contains(strings.Join(first.Risks, ","), "thunder") {
+	if !strings.Contains(first.OverallCharacter, "Showers") || !strings.Contains(strings.Join(first.Risks, ","), "wind") {
 		t.Fatalf("first day = %#v, want conditions and risks", first)
 	}
 	if len(pkg.ThreeDay.RelevantAlerts) != 1 {
 		t.Fatalf("RelevantAlerts length = %d, want 1", len(pkg.ThreeDay.RelevantAlerts))
 	}
+	if pkg.ThreeDay.Discussion.ShortTerm != "Short-term rain chances remain focused today." {
+		t.Fatalf("Discussion.ShortTerm = %q, want short-term AFD narrative", pkg.ThreeDay.Discussion.ShortTerm)
+	}
+	if pkg.ThreeDay.Discussion.LongTerm != "Long-term warmth builds into the weekend." {
+		t.Fatalf("Discussion.LongTerm = %q, want long-term AFD narrative", pkg.ThreeDay.Discussion.LongTerm)
+	}
 }

internal/briefing/weekend.go

@@ -31,17 +31,16 @@ func BuildWeekend(ctx BuildContext, summaries []forecast.DailySummary) (Package,
 	if len(summaries) == 0 {
 		return Package{}, fmt.Errorf("weekend forecast summaries are required")
 	}
-	pkg := Package{
-		Metadata: BuildMetadata(ctx),
-		Weekend: &Weekend{
-			Discussion:   buildDiscussion(summaries[0].Discussion),
-			WeatherStory: buildWeatherStory(ctx.Bundle),
-		},
+	pkg := buildPackage(ctx)
+	pkg.Weekend = &Weekend{
+		Discussion:   buildDiscussion(summaries[0].Discussion),
+		WeatherStory: buildWeatherStory(ctx.Bundle),
 	}
 	for _, summary := range summaries {
 		pkg.Weekend.Days = append(pkg.Weekend.Days, buildOutlookDay(summary))
 	}
 	pkg.Weekend.RelevantAlerts = collectOutlookAlerts(pkg.Weekend.Days)
+	setRelevantAlertCount(&pkg.Metadata, len(pkg.Weekend.RelevantAlerts))
 	pkg.Weekend.Planning = buildWeekendPlanning(pkg.Weekend.Days, pkg.Weekend.Discussion, ctx.Bundle)
 	return pkg, nil
 }
@@ -96,9 +95,6 @@ func weekendRainStormNotes(date string, daypart forecast.DaypartSummary) []strin
 	if daypart.MaxPrecipitationProbability != nil && daypart.MaxPrecipitationProbability.Value >= 30 {
 		notes = append(notes, fmt.Sprintf("%s precipitation chance peaks near %.0f%%.", label, daypart.MaxPrecipitationProbability.Value))
 	}
-	if daypart.Indicators.Thunder {
-		notes = append(notes, label+" thunder risk is present.")
-	}
 	return notes
 }
 

internal/briefing/weekend_test.go

@@ -43,7 +43,7 @@ func TestWeekendBriefingBuildsPlanningInputs(t *testing.T) {
 						Value: gust,
 						Time:  mustParse("2026-05-30T16:00:00-05:00"),
 					},
-					Indicators: forecast.Indicators{Thunder: true, Wind: true},
+					Indicators: forecast.Indicators{Wind: true},
 					HourlyPeriods: []forecast.ForecastPeriod{
 						{
 							StartTime:       mustParse("2026-05-30T15:00:00-05:00"),
@@ -54,7 +54,12 @@ func TestWeekendBriefingBuildsPlanningInputs(t *testing.T) {
 				},
 			},
 			AlertOverlaps: []forecast.AlertOverlap{{Event: "Flood Watch"}},
-			Discussion:    &forecast.Discussion{Product: "discussion", KeyMessages: []string{"Timing may shift."}},
+			Discussion: &forecast.Discussion{
+				Product:     "discussion",
+				KeyMessages: []string{"Timing may shift."},
+				ShortTerm:   &forecast.DiscussionSection{Text: "Short-term showers exit before the weekend."},
+				LongTerm:    &forecast.DiscussionSection{Text: "Long-term weekend rain timing remains uncertain."},
+			},
 		},
 	}
 
@@ -79,10 +84,16 @@ func TestWeekendBriefingBuildsPlanningInputs(t *testing.T) {
 	if len(pkg.Weekend.Planning.WorstWeatherWindows) == 0 {
 		t.Fatalf("WorstWeatherWindows = %#v, want weather window", pkg.Weekend.Planning.WorstWeatherWindows)
 	}
-	if !strings.Contains(strings.Join(pkg.Weekend.Planning.RainStormTiming, " "), "thunder") {
-		t.Fatalf("RainStormTiming = %#v, want thunder timing", pkg.Weekend.Planning.RainStormTiming)
+	if !strings.Contains(strings.Join(pkg.Weekend.Planning.RainStormTiming, " "), "precipitation") {
+		t.Fatalf("RainStormTiming = %#v, want precipitation timing", pkg.Weekend.Planning.RainStormTiming)
 	}
 	if len(pkg.Weekend.Planning.UncertaintyInputs) == 0 {
 		t.Fatal("UncertaintyInputs length = 0, want discussion context")
 	}
+	if pkg.Weekend.Discussion.ShortTerm != "Short-term showers exit before the weekend." {
+		t.Fatalf("Discussion.ShortTerm = %q, want short-term AFD narrative", pkg.Weekend.Discussion.ShortTerm)
+	}
+	if pkg.Weekend.Discussion.LongTerm != "Long-term weekend rain timing remains uncertain." {
+		t.Fatalf("Discussion.LongTerm = %q, want long-term AFD narrative", pkg.Weekend.Discussion.LongTerm)
+	}
 }

internal/changes/daily.go

@@ -126,7 +126,6 @@ func compareIndicators(previous forecast.Indicators, current forecast.Indicators
 		previous bool
 		current  bool
 	}{
-		{name: "thunder", previous: previous.Thunder, current: current.Thunder},
 		{name: "snow", previous: previous.Snow, current: current.Snow},
 		{name: "ice", previous: previous.Ice, current: current.Ice},
 	} {
@@ -146,7 +145,6 @@ func compareIndicators(previous forecast.Indicators, current forecast.Indicators
 func aggregateIndicators(dayparts []forecast.DaypartSummary) forecast.Indicators {
 	out := forecast.Indicators{}
 	for _, daypart := range dayparts {
-		out.Thunder = out.Thunder || daypart.Indicators.Thunder
 		out.Snow = out.Snow || daypart.Indicators.Snow
 		out.Ice = out.Ice || daypart.Indicators.Ice
 	}

internal/changes/daily_test.go

@@ -62,14 +62,14 @@ func TestCompareDailyAlertAddedAndRemoved(t *testing.T) {
 
 func TestCompareDailyIndicatorChange(t *testing.T) {
 	previous := dailyBriefing(60, 70, 10, at("2026-05-29T08:00:00Z"), nil, forecast.Indicators{})
-	current := dailyBriefing(60, 70, 10, at("2026-05-29T08:00:00Z"), nil, forecast.Indicators{Thunder: true})
+	current := dailyBriefing(60, 70, 10, at("2026-05-29T08:00:00Z"), nil, forecast.Indicators{Snow: true})
 
 	changes, err := CompareDaily(previous, current, testThresholds())
 	if err != nil {
 		t.Fatalf("CompareDaily() error = %v", err)
 	}
-	if countType(changes, "thunder_risk_change") != 1 {
-		t.Fatalf("changes = %#v, want thunder risk change", changes)
+	if countType(changes, "snow_risk_change") != 1 {
+		t.Fatalf("changes = %#v, want snow risk change", changes)
 	}
 }
 

internal/changes/three_day_test.go

@@ -34,7 +34,7 @@ func TestCompareThreeDayDetectsDayChanges(t *testing.T) {
 				Value: currentPrecip,
 				Time:  time.Date(2026, 5, 29, 12, 0, 0, 0, time.UTC),
 			},
-			Dayparts: []forecast.DaypartSummary{{Indicators: forecast.Indicators{Thunder: true}}},
+			Dayparts: []forecast.DaypartSummary{{Indicators: forecast.Indicators{Snow: true}}},
 		}}},
 	}
 
@@ -51,16 +51,16 @@ func TestCompareThreeDayDetectsDayChanges(t *testing.T) {
 		t.Fatal("changes length = 0, want detected 3-day changes")
 	}
 	var foundPrecip bool
-	var foundThunder bool
+	var foundSnow bool
 	for _, change := range changes {
 		if change.Type == "outlook_precip_probability_change" {
 			foundPrecip = true
 		}
-		if change.Type == "outlook_thunder_risk_change" {
-			foundThunder = true
+		if change.Type == "outlook_snow_risk_change" {
+			foundSnow = true
 		}
 	}
-	if !foundPrecip || !foundThunder {
-		t.Fatalf("changes = %#v, want precipitation and thunder changes", changes)
+	if !foundPrecip || !foundSnow {
+		t.Fatalf("changes = %#v, want precipitation and snow changes", changes)
 	}
 }

internal/changes/weekend_test.go

@@ -23,7 +23,7 @@ func TestCompareWeekendDetectsOutlookChanges(t *testing.T) {
 		Weekend: &briefing.Weekend{Days: []briefing.OutlookDay{{
 			Date:        "2026-05-30",
 			Temperature: forecast.Range{Max: &currentTemp},
-			Dayparts:    []forecast.DaypartSummary{{Indicators: forecast.Indicators{Thunder: true}}},
+			Dayparts:    []forecast.DaypartSummary{{Indicators: forecast.Indicators{Snow: true}}},
 		}}},
 	}
 
@@ -35,9 +35,9 @@ func TestCompareWeekendDetectsOutlookChanges(t *testing.T) {
 		t.Fatal("changes length = 0, want weekend changes")
 	}
 	for _, change := range changes {
-		if change.Type == "weekend_outlook_thunder_risk_change" {
+		if change.Type == "weekend_outlook_snow_risk_change" {
 			return
 		}
 	}
-	t.Fatalf("changes = %#v, want thunder risk change", changes)
+	t.Fatalf("changes = %#v, want snow risk change", changes)
 }

internal/cli/root.go

@@ -9,6 +9,7 @@ import (
 
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/app"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
 )
 
@@ -72,7 +73,7 @@ func (r Runner) Run(ctx context.Context, args []string, stdout io.Writer, stderr
 		result, err := app.RunBatchDetailed(ctx, req)
 		if result != nil {
 			writeRunLogs(stderr, result)
-			if encodeErr := writeRunSummary(stdout, result); encodeErr != nil {
+			if encodeErr := writeJSON(stdout, result); encodeErr != nil {
 				return encodeErr
 			}
 			if result.Failed > 0 {
@@ -108,6 +109,29 @@ type inspectOptions struct {
 	RunID      string
 }
 
+type inspectRunCommand struct {
+	Name    string
+	Inspect func(context.Context, app.InspectRunRequest) (any, error)
+}
+
+var inspectRunCommands = []inspectRunCommand{
+	{Name: "metadata", Inspect: func(ctx context.Context, req app.InspectRunRequest) (any, error) {
+		return app.InspectMetadata(ctx, req)
+	}},
+	{Name: "briefing", Inspect: func(ctx context.Context, req app.InspectRunRequest) (any, error) {
+		return app.InspectBriefing(ctx, req)
+	}},
+	{Name: "data-package", Inspect: func(ctx context.Context, req app.InspectRunRequest) (any, error) {
+		return app.InspectDataPackage(ctx, req)
+	}},
+	{Name: "prior", Inspect: func(ctx context.Context, req app.InspectRunRequest) (any, error) {
+		return app.InspectPriorSnapshot(ctx, req)
+	}},
+	{Name: "sources", Inspect: func(ctx context.Context, req app.InspectRunRequest) (any, error) {
+		return app.InspectSources(ctx, req)
+	}},
+}
+
 func (r Runner) runInspect(ctx context.Context, args []string, stdout io.Writer) error {
 	if len(args) == 0 {
 		return fmt.Errorf("inspect requires a command")
@@ -128,81 +152,32 @@ func (r Runner) runInspect(ctx context.Context, args []string, stdout io.Writer)
 			return err
 		}
 		return writeJSON(stdout, records)
-	case "metadata":
-		opts, err := parseInspectRunFlags(command, args[1:])
-		if err != nil {
-			return err
-		}
-		cfg, err := config.Load(config.LoadOptions{Path: opts.ConfigPath})
-		if err != nil {
-			return err
-		}
-		metadata, err := app.InspectMetadata(ctx, app.InspectRunRequest{Config: cfg, RunID: opts.RunID})
-		if err != nil {
-			return err
-		}
-		return writeJSON(stdout, metadata)
-	case "briefing":
-		opts, err := parseInspectRunFlags(command, args[1:])
-		if err != nil {
-			return err
-		}
-		cfg, err := config.Load(config.LoadOptions{Path: opts.ConfigPath})
-		if err != nil {
-			return err
-		}
-		pkg, err := app.InspectBriefing(ctx, app.InspectRunRequest{Config: cfg, RunID: opts.RunID})
-		if err != nil {
-			return err
-		}
-		return writeJSON(stdout, pkg)
-	case "data-package":
-		opts, err := parseInspectRunFlags(command, args[1:])
-		if err != nil {
-			return err
-		}
-		cfg, err := config.Load(config.LoadOptions{Path: opts.ConfigPath})
-		if err != nil {
-			return err
-		}
-		pkg, err := app.InspectDataPackage(ctx, app.InspectRunRequest{Config: cfg, RunID: opts.RunID})
-		if err != nil {
-			return err
-		}
-		return writeJSON(stdout, pkg)
-	case "prior":
-		opts, err := parseInspectRunFlags(command, args[1:])
-		if err != nil {
-			return err
-		}
-		cfg, err := config.Load(config.LoadOptions{Path: opts.ConfigPath})
-		if err != nil {
-			return err
-		}
-		prior, err := app.InspectPriorSnapshot(ctx, app.InspectRunRequest{Config: cfg, RunID: opts.RunID})
-		if err != nil {
-			return err
-		}
-		return writeJSON(stdout, prior)
-	case "sources":
-		opts, err := parseInspectRunFlags(command, args[1:])
-		if err != nil {
-			return err
-		}
-		cfg, err := config.Load(config.LoadOptions{Path: opts.ConfigPath})
-		if err != nil {
-			return err
-		}
-		sources, err := app.InspectSources(ctx, app.InspectRunRequest{Config: cfg, RunID: opts.RunID})
-		if err != nil {
-			return err
-		}
-		return writeJSON(stdout, sources)
 	default:
+		for _, candidate := range inspectRunCommands {
+			if candidate.Name == command {
+				return runInspectRunCommand(ctx, stdout, candidate, args[1:])
+			}
+		}
 		return fmt.Errorf("unknown inspect command %q", command)
 	}
 }
 
+func runInspectRunCommand(ctx context.Context, stdout io.Writer, command inspectRunCommand, args []string) error {
+	opts, err := parseInspectRunFlags(command.Name, args)
+	if err != nil {
+		return err
+	}
+	cfg, err := config.Load(config.LoadOptions{Path: opts.ConfigPath})
+	if err != nil {
+		return err
+	}
+	value, err := command.Inspect(ctx, app.InspectRunRequest{Config: cfg, RunID: opts.RunID})
+	if err != nil {
+		return err
+	}
+	return writeJSON(stdout, value)
+}
+
 func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
 	if r.Clock == nil {
 		r.Clock = timeutil.SystemClock{}
@@ -210,12 +185,12 @@ func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
 	if len(args) == 0 {
 		return app.GenerateRequest{}, fmt.Errorf("generate requires a report name")
 	}
-	report, ok := reportKind(args[0])
+	reportKind, ok := reportKind(args[0])
 	if !ok {
 		return app.GenerateRequest{}, fmt.Errorf("unknown generate report %q", args[0])
 	}
 
-	opts, err := parseGenerateFlags(report, args[1:])
+	opts, err := parseGenerateFlags(reportKind, args[1:])
 	if err != nil {
 		return app.GenerateRequest{}, err
 	}
@@ -223,7 +198,6 @@ func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
 		Path:     opts.ConfigPath,
 		Units:    opts.Units,
 		Timezone: opts.Timezone,
-		Output:   opts.Output,
 	})
 	if err != nil {
 		return app.GenerateRequest{}, err
@@ -235,12 +209,12 @@ func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
 
 	req := app.GenerateRequest{
 		Config:     cfg,
-		Report:     report,
+		Report:     reportKind,
 		OutputPath: opts.Output,
 		Now:        r.Clock.Now(),
 	}
 
-	switch report {
+	switch reportKind {
 	case app.ReportDaily:
 		if opts.Date == "" {
 			req.Date = timeutil.LocalDate(r.Clock.Now(), location)
@@ -257,17 +231,12 @@ func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
 		if opts.End == "" {
 			return app.GenerateRequest{}, fmt.Errorf("generate storm requires --end")
 		}
-		req.StormStart, err = timeutil.ParseStormTime(opts.Start, location)
+		period, err := report.ParseStormPeriod(opts.Start, opts.End, location)
 		if err != nil {
 			return app.GenerateRequest{}, err
 		}
-		req.StormEnd, err = timeutil.ParseStormTime(opts.End, location)
-		if err != nil {
-			return app.GenerateRequest{}, err
-		}
-		if !req.StormEnd.After(req.StormStart) {
-			return app.GenerateRequest{}, fmt.Errorf("generate storm requires --end after --start")
-		}
+		req.StormStart = period.Start
+		req.StormEnd = period.End
 	}
 
 	return req, nil
@@ -372,12 +341,6 @@ func parseInspectRunFlags(command string, args []string) (inspectOptions, error)
 	return opts, nil
 }
 
-func writeRunSummary(stdout io.Writer, result *app.BatchResult) error {
-	encoder := json.NewEncoder(stdout)
-	encoder.SetIndent("", "  ")
-	return encoder.Encode(result)
-}
-
 func writeJSON(stdout io.Writer, value any) error {
 	encoder := json.NewEncoder(stdout)
 	encoder.SetIndent("", "  ")

internal/cli/root_test.go

@@ -62,12 +62,8 @@ func TestRunGenerateStormWritesMarkdownReport(t *testing.T) {
 	server := dailyServer(t)
 	tempDir := t.TempDir()
 	scriptoriumPath := writeFakeScriptorium(t, tempDir)
-	configPath := filepath.Join(tempDir, "config.yml")
 	workspaceRoot := filepath.Join(tempDir, "workspace")
-	configBody := "weather_api:\n  base_url: " + server.URL + "/\n  timezone: America/Chicago\nscriptorium:\n  binary: " + scriptoriumPath + "\nworkspace:\n  root: " + workspaceRoot + "\n"
-	if err := os.WriteFile(configPath, []byte(configBody), 0o600); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
+	configPath := writeTestConfig(t, server, scriptoriumPath, workspaceRoot)
 	outPath := filepath.Join(tempDir, "storm.md")
 	var stdout bytes.Buffer
 	var stderr bytes.Buffer
@@ -90,14 +86,8 @@ func TestRunGenerateStormWritesMarkdownReport(t *testing.T) {
 	if !strings.Contains(string(report), "# Daily Report") {
 		t.Fatalf("report output missing markdown:\n%s", string(report))
 	}
-	dataPackageMatches, err := filepath.Glob(filepath.Join(workspaceRoot, "data-packages", "storm", "2026-05-29", "*.data_package.json"))
-	if err != nil {
-		t.Fatalf("glob data package: %v", err)
-	}
-	if len(dataPackageMatches) != 1 {
-		t.Fatalf("data package files = %#v, want one", dataPackageMatches)
-	}
-	data, err := os.ReadFile(dataPackageMatches[0])
+	dataPackagePath := oneArtifact(t, workspaceRoot, "data-packages", "storm", "2026-05-29", "*.data_package.json")
+	data, err := os.ReadFile(dataPackagePath)
 	if err != nil {
 		t.Fatalf("read managed data package: %v", err)
 	}
@@ -110,12 +100,8 @@ func TestRunGenerateTomorrowWritesMarkdownReport(t *testing.T) {
 	server := dailyServer(t)
 	tempDir := t.TempDir()
 	scriptoriumPath := writeFakeScriptorium(t, tempDir)
-	configPath := filepath.Join(tempDir, "config.yml")
 	workspaceRoot := filepath.Join(tempDir, "workspace")
-	configBody := "weather_api:\n  base_url: " + server.URL + "/\n  timezone: America/Chicago\nscriptorium:\n  binary: " + scriptoriumPath + "\nworkspace:\n  root: " + workspaceRoot + "\n"
-	if err := os.WriteFile(configPath, []byte(configBody), 0o600); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
+	configPath := writeTestConfig(t, server, scriptoriumPath, workspaceRoot)
 	outPath := filepath.Join(tempDir, "tomorrow.md")
 	var stdout bytes.Buffer
 	var stderr bytes.Buffer
@@ -136,14 +122,8 @@ func TestRunGenerateTomorrowWritesMarkdownReport(t *testing.T) {
 	if !strings.Contains(string(report), "# Daily Report") {
 		t.Fatalf("report output missing markdown:\n%s", string(report))
 	}
-	dataPackageMatches, err := filepath.Glob(filepath.Join(workspaceRoot, "data-packages", "daily", "2026-05-30", "*.data_package.json"))
-	if err != nil {
-		t.Fatalf("glob data package: %v", err)
-	}
-	if len(dataPackageMatches) != 1 {
-		t.Fatalf("data package files = %#v, want one", dataPackageMatches)
-	}
-	data, err := os.ReadFile(dataPackageMatches[0])
+	dataPackagePath := oneArtifact(t, workspaceRoot, "data-packages", "daily", "2026-05-30", "*.data_package.json")
+	data, err := os.ReadFile(dataPackagePath)
 	if err != nil {
 		t.Fatalf("read managed data package: %v", err)
 	}
@@ -457,6 +437,7 @@ func TestRunGenerateDailyWritesMarkdownReport(t *testing.T) {
 		"generate", "daily",
 		"--config", configPath,
 		"--date", "2026-05-29",
+		"--tz", "UTC",
 		"--out", outPath,
 	}, &stdout, &stderr)
 	if err != nil {
@@ -483,6 +464,24 @@ func TestRunGenerateDailyWritesMarkdownReport(t *testing.T) {
 	if !strings.Contains(string(data), `data_package.v1`) || !strings.Contains(string(data), `"daily_today"`) {
 		t.Fatalf("data package output missing expected content:\n%s", string(data))
 	}
+	var decoded struct {
+		Briefing struct {
+			Metadata struct {
+				Location struct {
+					ID       string `json:"id"`
+					Name     string `json:"name"`
+					Region   string `json:"region"`
+					Timezone string `json:"timezone"`
+				} `json:"location"`
+			} `json:"metadata"`
+		} `json:"briefing"`
+	}
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("decode data package: %v", err)
+	}
+	if decoded.Briefing.Metadata.Location.ID != "home" || decoded.Briefing.Metadata.Location.Name != "Brentwood" || decoded.Briefing.Metadata.Location.Region != "St. Louis Metro" || decoded.Briefing.Metadata.Location.Timezone != "UTC" {
+		t.Fatalf("location = %#v, want configured location with overridden timezone", decoded.Briefing.Metadata.Location)
+	}
 	preflightMatches, err := filepath.Glob(filepath.Join(workspaceRoot, "preflight", "daily", "2026-05-29", "*.render.json"))
 	if err != nil {
 		t.Fatalf("glob preflight: %v", err)
@@ -581,6 +580,45 @@ func TestRunInspectMissingMetadata(t *testing.T) {
 	}
 }
 
+func TestRunInspectRunCommandsParseRunIDAndConfig(t *testing.T) {
+	tempDir := t.TempDir()
+	configPath := filepath.Join(tempDir, "config.yml")
+	configBody := "workspace:\n  root: " + filepath.Join(tempDir, "workspace") + "\n"
+	if err := os.WriteFile(configPath, []byte(configBody), 0o600); err != nil {
+		t.Fatalf("write config: %v", err)
+	}
+	runner := Runner{Clock: fixedClock()}
+	commands := []string{"metadata", "briefing", "data-package", "prior", "sources"}
+
+	for _, command := range commands {
+		t.Run(command+" requires run id", func(t *testing.T) {
+			var stdout bytes.Buffer
+			var stderr bytes.Buffer
+
+			err := runner.Run(context.Background(), []string{"inspect", command, "--config", configPath}, &stdout, &stderr)
+			if err == nil {
+				t.Fatal("Run() error = nil, want missing run id error")
+			}
+			if !strings.Contains(err.Error(), "requires a run id") {
+				t.Fatalf("error = %q, want missing run id context", err.Error())
+			}
+		})
+
+		t.Run(command+" accepts config", func(t *testing.T) {
+			var stdout bytes.Buffer
+			var stderr bytes.Buffer
+
+			err := runner.Run(context.Background(), []string{"inspect", command, "--config", configPath, "missing"}, &stdout, &stderr)
+			if err == nil {
+				t.Fatal("Run() error = nil, want missing metadata error")
+			}
+			if !strings.Contains(err.Error(), "metadata for run id") {
+				t.Fatalf("error = %q, want missing metadata context", err.Error())
+			}
+		})
+	}
+}
+
 func TestResolveGenerateCommands(t *testing.T) {
 	runner := Runner{Clock: fixedClock()}
 	tests := []struct {
@@ -643,7 +681,15 @@ func TestResolveGenerateAppliesSharedFlags(t *testing.T) {
 func TestResolveGenerateStormRequiresStartAndEnd(t *testing.T) {
 	runner := Runner{Clock: fixedClock()}
 
-	_, err := runner.resolveGenerate([]string{"storm", "--start", "2026-05-29T18:00"})
+	_, err := runner.resolveGenerate([]string{"storm", "--end", "2026-05-29T18:00"})
+	if err == nil {
+		t.Fatal("resolveGenerate() error = nil, want missing start error")
+	}
+	if !strings.Contains(err.Error(), "requires --start") {
+		t.Fatalf("error = %q, want missing start", err.Error())
+	}
+
+	_, err = runner.resolveGenerate([]string{"storm", "--start", "2026-05-29T18:00"})
 	if err == nil {
 		t.Fatal("resolveGenerate() error = nil, want missing end error")
 	}
@@ -652,6 +698,26 @@ func TestResolveGenerateStormRequiresStartAndEnd(t *testing.T) {
 	}
 }
 
+func TestResolveGenerateStormParsesLocalTimestamps(t *testing.T) {
+	runner := Runner{Clock: fixedClock()}
+
+	req, err := runner.resolveGenerate([]string{
+		"storm",
+		"--tz", "America/Chicago",
+		"--start", "2026-05-29T18:00",
+		"--end", "2026-05-30T06:00",
+	})
+	if err != nil {
+		t.Fatalf("resolveGenerate() error = %v", err)
+	}
+	if got := req.StormStart.Format(time.RFC3339); got != "2026-05-29T18:00:00-05:00" {
+		t.Fatalf("StormStart = %q, want local Chicago time", got)
+	}
+	if got := req.StormEnd.Format(time.RFC3339); got != "2026-05-30T06:00:00-05:00" {
+		t.Fatalf("StormEnd = %q, want local Chicago time", got)
+	}
+}
+
 func TestResolveGenerateStormParsesRFC3339(t *testing.T) {
 	runner := Runner{Clock: fixedClock()}
 
@@ -668,6 +734,22 @@ func TestResolveGenerateStormParsesRFC3339(t *testing.T) {
 	}
 }
 
+func TestResolveGenerateStormRejectsInvalidBounds(t *testing.T) {
+	runner := Runner{Clock: fixedClock()}
+
+	_, err := runner.resolveGenerate([]string{
+		"storm",
+		"--start", "2026-05-30T06:00",
+		"--end", "2026-05-29T18:00",
+	})
+	if err == nil {
+		t.Fatal("resolveGenerate() error = nil, want invalid bounds error")
+	}
+	if !strings.Contains(err.Error(), "end time after start time") {
+		t.Fatalf("error = %q, want invalid bounds context", err.Error())
+	}
+}
+
 func TestResolveRunCommands(t *testing.T) {
 	tests := []struct {
 		name string
@@ -739,6 +821,28 @@ func dailyServer(t *testing.T) *httptest.Server {
 	return server
 }
 
+func writeTestConfig(t *testing.T, server *httptest.Server, scriptoriumPath string, workspaceRoot string) string {
+	t.Helper()
+	configPath := filepath.Join(t.TempDir(), "config.yml")
+	configBody := "weather_api:\n  base_url: " + server.URL + "/\n  timezone: America/Chicago\nscriptorium:\n  binary: " + scriptoriumPath + "\nworkspace:\n  root: " + workspaceRoot + "\n"
+	if err := os.WriteFile(configPath, []byte(configBody), 0o600); err != nil {
+		t.Fatalf("write config: %v", err)
+	}
+	return configPath
+}
+
+func oneArtifact(t *testing.T, root string, parts ...string) string {
+	t.Helper()
+	matches, err := filepath.Glob(filepath.Join(append([]string{root}, parts...)...))
+	if err != nil {
+		t.Fatalf("glob artifact: %v", err)
+	}
+	if len(matches) != 1 {
+		t.Fatalf("artifact matches = %#v, want one", matches)
+	}
+	return matches[0]
+}
+
 func writeFakeScriptorium(t *testing.T, dir string) string {
 	t.Helper()
 	path := filepath.Join(dir, "scriptorium")

internal/config/config.go

@@ -14,10 +14,10 @@ const (
 
 type Config struct {
 	WeatherAPI    WeatherAPIConfig    `yaml:"weather_api"`
+	Location      LocationConfig      `yaml:"location"`
 	MissingSource MissingSourceConfig `yaml:"missing_source"`
 	Scriptorium   ScriptoriumConfig   `yaml:"scriptorium"`
 	Workspace     WorkspaceConfig     `yaml:"workspace"`
-	Reports       ReportOutputConfig  `yaml:"reports"`
 	Dayparts      []DaypartConfig     `yaml:"dayparts"`
 	RecentChange  RecentChangeConfig  `yaml:"recent_change"`
 }
@@ -31,6 +31,12 @@ type WeatherAPIConfig struct {
 	Format    string        `yaml:"format"`
 }
 
+type LocationConfig struct {
+	ID     string `yaml:"id"`
+	Name   string `yaml:"name"`
+	Region string `yaml:"region"`
+}
+
 type MissingSourceConfig struct {
 	Default MissingSourcePolicy            `yaml:"default"`
 	Sources map[string]MissingSourcePolicy `yaml:"sources"`
@@ -52,11 +58,6 @@ type WorkspaceConfig struct {
 	PreflightDir    string `yaml:"preflight_dir"`
 }
 
-type ReportOutputConfig struct {
-	OutputDir string            `yaml:"output_dir"`
-	Paths     map[string]string `yaml:"paths"`
-}
-
 type DaypartConfig struct {
 	Name  string `yaml:"name"`
 	Start string `yaml:"start"`

internal/config/config_test.go

@@ -17,12 +17,15 @@ func TestDefaults(t *testing.T) {
 	if cfg.WeatherAPI.Units != "us" {
 		t.Fatalf("Units = %q, want us", cfg.WeatherAPI.Units)
 	}
-	if cfg.WeatherAPI.Timezone != "Chicago" {
-		t.Fatalf("Timezone = %q, want Chicago", cfg.WeatherAPI.Timezone)
+	if cfg.WeatherAPI.Timezone != "America/Chicago" {
+		t.Fatalf("Timezone = %q, want America/Chicago", cfg.WeatherAPI.Timezone)
 	}
 	if cfg.WeatherAPI.Format != "json" {
 		t.Fatalf("Format = %q, want json", cfg.WeatherAPI.Format)
 	}
+	if cfg.Location.ID != "home" || cfg.Location.Name != "Brentwood" || cfg.Location.Region != "St. Louis Metro" {
+		t.Fatalf("Location = %#v, want home/Brentwood/St. Louis Metro", cfg.Location)
+	}
 	if cfg.MissingSource.Default != MissingSourceWarn {
 		t.Fatalf("MissingSource.Default = %q, want warn", cfg.MissingSource.Default)
 	}
@@ -34,8 +37,8 @@ func TestLoadExampleConfig(t *testing.T) {
 		t.Fatalf("LoadFile() error = %v", err)
 	}
 
-	if cfg.WeatherAPI.BaseURL != "https://weather.api.example.com/" {
-		t.Fatalf("BaseURL = %q, want example URL", cfg.WeatherAPI.BaseURL)
+	if cfg.WeatherAPI.BaseURL != "https://weather.api.rakestrawhome.com/" {
+		t.Fatalf("BaseURL = %q, want configured example URL", cfg.WeatherAPI.BaseURL)
 	}
 	if cfg.WeatherAPI.Timeout != 15*time.Second {
 		t.Fatalf("Timeout = %s, want 15s", cfg.WeatherAPI.Timeout)
@@ -43,6 +46,9 @@ func TestLoadExampleConfig(t *testing.T) {
 	if cfg.MissingSource.Sources["alerts"] != MissingSourceNone {
 		t.Fatalf("alerts policy = %q, want none", cfg.MissingSource.Sources["alerts"])
 	}
+	if cfg.Location.ID != "home" || cfg.Location.Name != "Brentwood" || cfg.Location.Region != "St. Louis Metro" {
+		t.Fatalf("Location = %#v, want example location", cfg.Location)
+	}
 }
 
 func TestLoadMinimalExampleConfig(t *testing.T) {
@@ -63,6 +69,9 @@ func TestLoadMinimalExampleConfig(t *testing.T) {
 	if cfg.Workspace.Root != "workspace" {
 		t.Fatalf("Workspace.Root = %q, want default workspace", cfg.Workspace.Root)
 	}
+	if cfg.Location.Name != "Brentwood" {
+		t.Fatalf("Location.Name = %q, want default Brentwood", cfg.Location.Name)
+	}
 }
 
 func TestExplicitMissingConfigReturnsError(t *testing.T) {
@@ -92,7 +101,7 @@ func TestInvalidConfigProducesActionableError(t *testing.T) {
 }
 
 func TestLoadAppliesOverrides(t *testing.T) {
-	cfg, err := Load(LoadOptions{Units: "metric", Timezone: "+09:30", Output: "./out"})
+	cfg, err := Load(LoadOptions{Units: "metric", Timezone: "+09:30"})
 	if err != nil {
 		t.Fatalf("Load() error = %v", err)
 	}
@@ -102,7 +111,4 @@ func TestLoadAppliesOverrides(t *testing.T) {
 	if cfg.WeatherAPI.Timezone != "+09:30" {
 		t.Fatalf("Timezone = %q, want +09:30", cfg.WeatherAPI.Timezone)
 	}
-	if cfg.Reports.OutputDir != "./out" {
-		t.Fatalf("OutputDir = %q, want ./out", cfg.Reports.OutputDir)
-	}
 }

internal/config/defaults.go

@@ -10,9 +10,14 @@ func Defaults() Config {
 			Timeout:   10 * time.Second,
 			Precision: 1,
 			Units:     "us",
-			Timezone:  "Chicago",
+			Timezone:  "America/Chicago",
 			Format:    "json",
 		},
+		Location: LocationConfig{
+			ID:     "home",
+			Name:   "Brentwood",
+			Region: "St. Louis Metro",
+		},
 		MissingSource: MissingSourceConfig{
 			Default: MissingSourceWarn,
 			Sources: map[string]MissingSourcePolicy{},
@@ -28,15 +33,12 @@ func Defaults() Config {
 			DataPackagesDir: "data-packages",
 			PreflightDir:    "preflight",
 		},
-		Reports: ReportOutputConfig{
-			OutputDir: "reports",
-			Paths:     map[string]string{},
-		},
 		Dayparts: []DaypartConfig{
 			{Name: "overnight", Start: "00:00", End: "06:00"},
-			{Name: "morning", Start: "06:00", End: "12:00"},
-			{Name: "afternoon", Start: "12:00", End: "18:00"},
-			{Name: "evening", Start: "18:00", End: "24:00"},
+			{Name: "morning", Start: "06:00", End: "10:00"},
+			{Name: "midday", Start: "10:00", End: "15:00"},
+			{Name: "afternoon", Start: "15:00", End: "17:00"},
+			{Name: "evening", Start: "17:00", End: "24:00"},
 		},
 		RecentChange: RecentChangeConfig{
 			TemperatureDegrees:       5,

internal/config/load.go

@@ -12,7 +12,6 @@ type LoadOptions struct {
 	Path     string
 	Units    string
 	Timezone string
-	Output   string
 }
 
 func Load(opts LoadOptions) (Config, error) {
@@ -35,9 +34,6 @@ func Load(opts LoadOptions) (Config, error) {
 	if opts.Timezone != "" {
 		cfg.WeatherAPI.Timezone = opts.Timezone
 	}
-	if opts.Output != "" {
-		cfg.Reports.OutputDir = opts.Output
-	}
 
 	if err := Validate(cfg); err != nil {
 		return Config{}, err
@@ -61,8 +57,5 @@ func mergeFile(cfg *Config, path string) error {
 	if cfg.MissingSource.Sources == nil {
 		cfg.MissingSource.Sources = map[string]MissingSourcePolicy{}
 	}
-	if cfg.Reports.Paths == nil {
-		cfg.Reports.Paths = map[string]string{}
-	}
 	return nil
 }

internal/config/validate.go

@@ -58,9 +58,6 @@ func Validate(cfg Config) error {
 	if cfg.Workspace.Root == "" {
 		return fmt.Errorf("workspace.root is required")
 	}
-	if cfg.Reports.OutputDir == "" {
-		return fmt.Errorf("reports.output_dir is required")
-	}
 	if len(cfg.Dayparts) == 0 {
 		return fmt.Errorf("dayparts must contain at least one entry")
 	}

internal/fileutil/fileutil.go

@@ -0,0 +1,48 @@
+// Package fileutil provides narrow filesystem helpers for durable artifacts.
+package fileutil
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+func WriteFileAtomic(path string, data []byte) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return fmt.Errorf("create directory %q: %w", filepath.Dir(path), err)
+	}
+	tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")
+	if err != nil {
+		return fmt.Errorf("create temporary file for %q: %w", path, err)
+	}
+	tmpName := tmp.Name()
+	defer os.Remove(tmpName)
+	if _, err := tmp.Write(data); err != nil {
+		tmp.Close()
+		return fmt.Errorf("write temporary file for %q: %w", path, err)
+	}
+	if err := tmp.Close(); err != nil {
+		return fmt.Errorf("close temporary file for %q: %w", path, err)
+	}
+	if err := os.Rename(tmpName, path); err != nil {
+		return fmt.Errorf("save %q: %w", path, err)
+	}
+	return nil
+}
+
+func WriteJSONAtomic(path string, value any) error {
+	data, err := json.MarshalIndent(value, "", "  ")
+	if err != nil {
+		return fmt.Errorf("marshal %q: %w", path, err)
+	}
+	return WriteFileAtomic(path, data)
+}
+
+func CopyFileAtomic(source string, target string) error {
+	data, err := os.ReadFile(source)
+	if err != nil {
+		return fmt.Errorf("read %q: %w", source, err)
+	}
+	return WriteFileAtomic(target, data)
+}

internal/fileutil/fileutil_test.go

@@ -0,0 +1,103 @@
+package fileutil
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestWriteFileAtomicCreatesParentDirectory(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "nested", "artifact.txt")
+
+	if err := WriteFileAtomic(path, []byte("artifact")); err != nil {
+		t.Fatalf("WriteFileAtomic() error = %v", err)
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("ReadFile() error = %v", err)
+	}
+	if string(data) != "artifact" {
+		t.Fatalf("data = %q, want artifact", data)
+	}
+}
+
+func TestWriteFileAtomicOverwritesTarget(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "artifact.txt")
+	if err := WriteFileAtomic(path, []byte("old")); err != nil {
+		t.Fatalf("WriteFileAtomic() initial error = %v", err)
+	}
+
+	if err := WriteFileAtomic(path, []byte("new")); err != nil {
+		t.Fatalf("WriteFileAtomic() overwrite error = %v", err)
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("ReadFile() error = %v", err)
+	}
+	if string(data) != "new" {
+		t.Fatalf("data = %q, want new", data)
+	}
+}
+
+func TestWriteFileAtomicCleansTemporaryFileAfterRenameError(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "target")
+	if err := os.Mkdir(target, 0o755); err != nil {
+		t.Fatalf("Mkdir() error = %v", err)
+	}
+
+	err := WriteFileAtomic(target, []byte("data"))
+	if err == nil {
+		t.Fatal("WriteFileAtomic() error = nil, want rename error")
+	}
+	if !strings.Contains(err.Error(), "save") {
+		t.Fatalf("error = %q, want save context", err.Error())
+	}
+	matches, err := filepath.Glob(filepath.Join(dir, ".target.*.tmp"))
+	if err != nil {
+		t.Fatalf("Glob() error = %v", err)
+	}
+	if len(matches) != 0 {
+		t.Fatalf("temporary files = %v, want none", matches)
+	}
+}
+
+func TestWriteJSONAtomic(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "artifact.json")
+
+	if err := WriteJSONAtomic(path, map[string]string{"status": "ok"}); err != nil {
+		t.Fatalf("WriteJSONAtomic() error = %v", err)
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("ReadFile() error = %v", err)
+	}
+	if string(data) != "{\n  \"status\": \"ok\"\n}" {
+		t.Fatalf("json = %q, want indented object", data)
+	}
+}
+
+func TestCopyFileAtomic(t *testing.T) {
+	dir := t.TempDir()
+	source := filepath.Join(dir, "source.txt")
+	target := filepath.Join(dir, "nested", "target.txt")
+	if err := os.WriteFile(source, []byte("copied"), 0o600); err != nil {
+		t.Fatalf("WriteFile() error = %v", err)
+	}
+
+	if err := CopyFileAtomic(source, target); err != nil {
+		t.Fatalf("CopyFileAtomic() error = %v", err)
+	}
+
+	data, err := os.ReadFile(target)
+	if err != nil {
+		t.Fatalf("ReadFile() error = %v", err)
+	}
+	if string(data) != "copied" {
+		t.Fatalf("data = %q, want copied", data)
+	}
+}

internal/forecast/bundle.go

@@ -149,8 +149,8 @@ type Discussion struct {
 }
 
 type DiscussionSection struct {
-	Title     string     `json:"title,omitempty"`
-	Narrative string     `json:"narrative,omitempty"`
+	Qualifier string     `json:"qualifier,omitempty"`
+	Text      string     `json:"text,omitempty"`
 	IssuedAt  *time.Time `json:"issuedAt,omitempty"`
 }
 

internal/forecast/derive.go

@@ -47,13 +47,12 @@ type TimedValue struct {
 }
 
 type Indicators struct {
-	Thunder bool `json:"thunder,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"`
+	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"`
 }
 
 type AlertOverlap struct {
@@ -291,11 +290,10 @@ func sortedKeys(values map[string]struct{}) []string {
 func indicatorsForText(text string) Indicators {
 	lower := strings.ToLower(text)
 	return Indicators{
-		Thunder: strings.Contains(lower, "thunder") || strings.Contains(lower, "storm"),
-		Snow:    strings.Contains(lower, "snow"),
-		Ice:     strings.Contains(lower, "ice") || strings.Contains(lower, "freezing") || strings.Contains(lower, "sleet"),
-		Fog:     strings.Contains(lower, "fog"),
-		Wind:    strings.Contains(lower, "wind") || strings.Contains(lower, "gust"),
+		Snow: strings.Contains(lower, "snow"),
+		Ice:  strings.Contains(lower, "ice") || strings.Contains(lower, "freezing") || strings.Contains(lower, "sleet"),
+		Fog:  strings.Contains(lower, "fog"),
+		Wind: strings.Contains(lower, "wind") || strings.Contains(lower, "gust"),
 	}
 }
 
@@ -318,13 +316,12 @@ func numericIndicators(period ForecastPeriod) Indicators {
 
 func mergeIndicators(left Indicators, right Indicators) Indicators {
 	return Indicators{
-		Thunder: left.Thunder || right.Thunder,
-		Snow:    left.Snow || right.Snow,
-		Ice:     left.Ice || right.Ice,
-		Fog:     left.Fog || right.Fog,
-		Heat:    left.Heat || right.Heat,
-		Cold:    left.Cold || right.Cold,
-		Wind:    left.Wind || right.Wind,
+		Snow: left.Snow || right.Snow,
+		Ice:  left.Ice || right.Ice,
+		Fog:  left.Fog || right.Fog,
+		Heat: left.Heat || right.Heat,
+		Cold: left.Cold || right.Cold,
+		Wind: left.Wind || right.Wind,
 	}
 }
 

internal/forecast/derive_test.go

@@ -41,10 +41,10 @@ func TestBuildDailySummaryGroupsDaypartsAndComputesMetrics(t *testing.T) {
 		t.Fatalf("morning peak gust = %#v, want 40", morning.PeakWindGust)
 	}
 	if morning.DominantCondition != "Thunderstorms and gusty wind" {
-		t.Fatalf("morning dominant = %q, want thunderstorm condition", morning.DominantCondition)
+		t.Fatalf("morning dominant = %q, want raw forecast condition", morning.DominantCondition)
 	}
-	if !morning.Indicators.Thunder || !morning.Indicators.Wind {
-		t.Fatalf("morning indicators = %#v, want thunder and wind", morning.Indicators)
+	if !morning.Indicators.Wind {
+		t.Fatalf("morning indicators = %#v, want wind", morning.Indicators)
 	}
 
 	afternoon := summary.Dayparts[2]
@@ -87,8 +87,8 @@ func TestBuildDailySummaryFromFixtureBundle(t *testing.T) {
 	if len(summary.Dayparts) != 2 {
 		t.Fatalf("Dayparts length = %d, want 2", len(summary.Dayparts))
 	}
-	if !summary.Dayparts[0].Indicators.Thunder {
-		t.Fatalf("morning indicators = %#v, want thunder", summary.Dayparts[0].Indicators)
+	if summary.Dayparts[0].DominantCondition != "Showers and thunderstorms" {
+		t.Fatalf("morning dominant = %q, want raw forecast condition", summary.Dayparts[0].DominantCondition)
 	}
 	if len(summary.AlertOverlaps) != 1 {
 		t.Fatalf("AlertOverlaps length = %d, want 1", len(summary.AlertOverlaps))

internal/forecast/testdata/daily_bundle.json

@@ -54,7 +54,15 @@
     "issuedAt": "2026-05-29T09:25:00-05:00",
     "keyMessages": [
       "Storms are most likely during the morning."
-    ]
+    ],
+    "shortTerm": {
+      "qualifier": "(Through This Evening)",
+      "text": "Morning showers taper as a weak boundary shifts east."
+    },
+    "longTerm": {
+      "qualifier": "(This Weekend)",
+      "text": "Warmer and more humid conditions return with periodic rain chances."
+    }
   },
   "sources": [
     {

internal/promptinput/package.go

@@ -2,14 +2,12 @@
 package promptinput
 
 import (
-	"encoding/json"
 	"fmt"
-	"os"
-	"path/filepath"
 	"time"
 
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/changes"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/fileutil"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/forecast"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
@@ -27,12 +25,13 @@ type Package struct {
 }
 
 type Report struct {
-	ID          report.ID       `json:"id"`
-	Variant     string          `json:"variant,omitempty"`
-	PromptID    string          `json:"promptId"`
-	GeneratedAt time.Time       `json:"generatedAt"`
-	Timezone    string          `json:"timezone"`
-	ValidPeriod timeutil.Period `json:"validPeriod"`
+	ID               report.ID       `json:"id"`
+	Variant          string          `json:"variant,omitempty"`
+	PromptID         string          `json:"promptId"`
+	GeneratedAt      time.Time       `json:"generatedAt"`
+	Timezone         string          `json:"timezone"`
+	CurrentLocalDate string          `json:"currentLocalDate"`
+	ValidPeriod      timeutil.Period `json:"validPeriod"`
 }
 
 type RecentChanges struct {
@@ -44,6 +43,10 @@ func Build(briefingPackage briefing.Package) (Package, error) {
 }
 
 func BuildWithRecentChanges(briefingPackage briefing.Package, recentChanges []changes.Change) (Package, error) {
+	localDate, err := currentLocalDate(briefingPackage.Metadata.GeneratedAt, briefingPackage.Metadata.Timezone)
+	if err != nil {
+		return Package{}, err
+	}
 	items := make([]changes.Change, len(recentChanges))
 	copy(items, recentChanges)
 	if items == nil {
@@ -53,12 +56,13 @@ func BuildWithRecentChanges(briefingPackage briefing.Package, recentChanges []ch
 		SchemaVersion: SchemaVersion,
 		RunID:         briefingPackage.Metadata.RunID,
 		Report: Report{
-			ID:          briefingPackage.Metadata.ReportID,
-			Variant:     briefingPackage.Metadata.Variant,
-			PromptID:    briefingPackage.Metadata.PromptID,
-			GeneratedAt: briefingPackage.Metadata.GeneratedAt,
-			Timezone:    briefingPackage.Metadata.Timezone,
-			ValidPeriod: briefingPackage.Metadata.ValidPeriod,
+			ID:               briefingPackage.Metadata.ReportID,
+			Variant:          briefingPackage.Metadata.Variant,
+			PromptID:         briefingPackage.Metadata.PromptID,
+			GeneratedAt:      briefingPackage.Metadata.GeneratedAt,
+			Timezone:         briefingPackage.Metadata.Timezone,
+			CurrentLocalDate: localDate,
+			ValidPeriod:      briefingPackage.Metadata.ValidPeriod,
 		},
 		Briefing:       briefingPackage,
 		RecentChanges:  RecentChanges{Items: items},
@@ -70,6 +74,14 @@ func BuildWithRecentChanges(briefingPackage briefing.Package, recentChanges []ch
 	return pkg, nil
 }
 
+func currentLocalDate(generatedAt time.Time, timezone string) (string, error) {
+	location, err := timeutil.LoadLocation(timezone)
+	if err != nil {
+		return "", fmt.Errorf("load report timezone %q: %w", timezone, err)
+	}
+	return generatedAt.In(location).Format(timeutil.DateLayout), nil
+}
+
 func Validate(pkg Package) error {
 	if pkg.SchemaVersion == "" {
 		return fmt.Errorf("schemaVersion is required")
@@ -89,6 +101,9 @@ func Validate(pkg Package) error {
 	if pkg.Report.Timezone == "" {
 		return fmt.Errorf("report.timezone is required")
 	}
+	if pkg.Report.CurrentLocalDate == "" {
+		return fmt.Errorf("report.currentLocalDate is required")
+	}
 	if !pkg.Report.ValidPeriod.IsValid() {
 		return fmt.Errorf("report.validPeriod must be valid")
 	}
@@ -117,29 +132,8 @@ func Save(path string, pkg Package) error {
 	if err := Validate(pkg); err != nil {
 		return err
 	}
-	data, err := json.MarshalIndent(pkg, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal data package: %w", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return fmt.Errorf("create data package directory %q: %w", filepath.Dir(path), err)
-	}
-	tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")
-	if err != nil {
-		return fmt.Errorf("create temporary data package file: %w", err)
-	}
-	tmpName := tmp.Name()
-	defer os.Remove(tmpName)
-
-	if _, err := tmp.Write(data); err != nil {
-		tmp.Close()
-		return fmt.Errorf("write temporary data package file: %w", err)
-	}
-	if err := tmp.Close(); err != nil {
-		return fmt.Errorf("close temporary data package file: %w", err)
-	}
-	if err := os.Rename(tmpName, path); err != nil {
-		return fmt.Errorf("save data package %q: %w", path, err)
+	if err := fileutil.WriteJSONAtomic(path, pkg); err != nil {
+		return fmt.Errorf("save data package: %w", err)
 	}
 	return nil
 }

internal/promptinput/package_test.go

@@ -28,14 +28,51 @@ func TestBuildDailyDataPackage(t *testing.T) {
 	if pkg.Report.PromptID != "weather.daily_report" {
 		t.Fatalf("PromptID = %q, want weather.daily_report", pkg.Report.PromptID)
 	}
+	if pkg.Report.CurrentLocalDate != "2026-05-29" {
+		t.Fatalf("CurrentLocalDate = %q, want 2026-05-29", pkg.Report.CurrentLocalDate)
+	}
 	if pkg.Briefing.Daily == nil {
 		t.Fatal("Briefing.Daily = nil")
 	}
+	if pkg.Briefing.Metadata.Location == nil || pkg.Briefing.Metadata.Location.Name != "Brentwood" {
+		t.Fatalf("Briefing.Metadata.Location = %#v, want configured location", pkg.Briefing.Metadata.Location)
+	}
+	if pkg.Briefing.CurrentConditions == nil || pkg.Briefing.CurrentConditions.ConditionText != "Partly cloudy" {
+		t.Fatalf("Briefing.CurrentConditions = %#v, want current conditions", pkg.Briefing.CurrentConditions)
+	}
 	if pkg.RecentChanges.Items == nil || len(pkg.RecentChanges.Items) != 0 {
 		t.Fatalf("RecentChanges.Items = %#v, want empty slice", pkg.RecentChanges.Items)
 	}
 }
 
+func TestBuildCurrentLocalDateUsesReportTimezone(t *testing.T) {
+	briefingPackage := validBriefingPackage()
+	briefingPackage.Metadata.GeneratedAt = time.Date(2026, 5, 30, 2, 30, 0, 0, time.UTC)
+	briefingPackage.Metadata.Timezone = "America/Chicago"
+
+	pkg, err := Build(briefingPackage)
+	if err != nil {
+		t.Fatalf("Build() error = %v", err)
+	}
+
+	if pkg.Report.CurrentLocalDate != "2026-05-29" {
+		t.Fatalf("CurrentLocalDate = %q, want local Chicago date 2026-05-29", pkg.Report.CurrentLocalDate)
+	}
+}
+
+func TestBuildRejectsInvalidReportTimezone(t *testing.T) {
+	briefingPackage := validBriefingPackage()
+	briefingPackage.Metadata.Timezone = "Not/AZone"
+
+	_, err := Build(briefingPackage)
+	if err == nil {
+		t.Fatal("Build() error = nil, want invalid timezone error")
+	}
+	if !strings.Contains(err.Error(), "report timezone") {
+		t.Fatalf("error = %q, want report timezone context", err.Error())
+	}
+}
+
 func TestValidateRequiresFields(t *testing.T) {
 	pkg, err := Build(validBriefingPackage())
 	if err != nil {
@@ -52,6 +89,22 @@ func TestValidateRequiresFields(t *testing.T) {
 	}
 }
 
+func TestValidateRequiresCurrentLocalDate(t *testing.T) {
+	pkg, err := Build(validBriefingPackage())
+	if err != nil {
+		t.Fatalf("Build() error = %v", err)
+	}
+	pkg.Report.CurrentLocalDate = ""
+
+	err = Validate(pkg)
+	if err == nil {
+		t.Fatal("Validate() error = nil, want required field error")
+	}
+	if !strings.Contains(err.Error(), "currentLocalDate") {
+		t.Fatalf("error = %q, want currentLocalDate context", err.Error())
+	}
+}
+
 func TestBuildThreeDayDataPackage(t *testing.T) {
 	briefingPackage := validBriefingPackage()
 	briefingPackage.Metadata.RunID = "20260529T100000Z_three_day"
@@ -155,11 +208,20 @@ func validBriefingPackage() briefing.Package {
 			GeneratedAt:   generatedAt,
 			Units:         "us",
 			Timezone:      "America/Chicago",
+			Location: &briefing.LocationContext{
+				ID:       "home",
+				Name:     "Brentwood",
+				Region:   "St. Louis Metro",
+				Timezone: "America/Chicago",
+			},
 			ValidPeriod: timeutil.Period{
 				Start: time.Date(2026, 5, 29, 5, 0, 0, 0, time.UTC),
 				End:   time.Date(2026, 5, 30, 5, 0, 0, 0, time.UTC),
 			},
 		},
+		CurrentConditions: &briefing.CurrentConditionsContext{
+			ConditionText: "Partly cloudy",
+		},
 		Daily: &briefing.Daily{
 			ForecastSummaryDate: "2026-05-29",
 		},

internal/report/definition.go

@@ -38,7 +38,10 @@ type Definition struct {
 	Name               string
 	PromptID           string
 	ComparisonStrategy ComparisonStrategy
-	DefaultOutputName  string
+	ArtifactGroup      string
+	BatchOutputName    string
+	Generated          bool
+	CompatiblePriorIDs []ID
 	Morning            bool
 	Evening            bool
 	resolve            func(ResolveRequest) (timeutil.Period, error)
@@ -51,6 +54,15 @@ func (d Definition) ResolvePeriod(req ResolveRequest) (timeutil.Period, error) {
 	return d.resolve(req)
 }
 
+func (d Definition) CompatibleWithPrior(id ID) bool {
+	for _, compatibleID := range d.CompatiblePriorIDs {
+		if id == compatibleID {
+			return true
+		}
+	}
+	return false
+}
+
 type ResolveRequest struct {
 	Now        time.Time
 	Location   *time.Location

internal/report/period_test.go

@@ -1,6 +1,7 @@
 package report
 
 import (
+	"reflect"
 	"strings"
 	"testing"
 	"time"
@@ -177,6 +178,79 @@ func TestRegistryDefinitionsHavePromptIDsAndComparisonStrategies(t *testing.T) {
 	}
 }
 
+func TestRegistryDefinitionsDeclarePathAndCompatibilityPolicy(t *testing.T) {
+	tests := []struct {
+		id                 ID
+		artifactGroup      string
+		batchOutputName    string
+		generated          bool
+		compatiblePriorIDs []ID
+	}{
+		{
+			id:                 DailyToday,
+			artifactGroup:      "daily",
+			batchOutputName:    "daily.md",
+			generated:          true,
+			compatiblePriorIDs: []ID{DailyToday, DailyTomorrow},
+		},
+		{
+			id:                 DailyTomorrow,
+			artifactGroup:      "daily",
+			batchOutputName:    "tomorrow.md",
+			generated:          true,
+			compatiblePriorIDs: []ID{DailyToday, DailyTomorrow},
+		},
+		{
+			id:                 ThreeDay,
+			artifactGroup:      "three-day",
+			batchOutputName:    "three-day.md",
+			generated:          true,
+			compatiblePriorIDs: []ID{ThreeDay},
+		},
+		{
+			id:                 Weekend,
+			artifactGroup:      "weekend",
+			batchOutputName:    "weekend.md",
+			generated:          true,
+			compatiblePriorIDs: []ID{Weekend},
+		},
+		{
+			id:                 Storm,
+			artifactGroup:      "storm",
+			batchOutputName:    "storm.md",
+			generated:          true,
+			compatiblePriorIDs: []ID{Storm},
+		},
+	}
+
+	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 definition.ArtifactGroup != tt.artifactGroup {
+				t.Fatalf("ArtifactGroup = %q, want %q", definition.ArtifactGroup, tt.artifactGroup)
+			}
+			if definition.BatchOutputName != tt.batchOutputName {
+				t.Fatalf("BatchOutputName = %q, want %q", definition.BatchOutputName, tt.batchOutputName)
+			}
+			if definition.Generated != tt.generated {
+				t.Fatalf("Generated = %t, want %t", definition.Generated, tt.generated)
+			}
+			if !reflect.DeepEqual(definition.CompatiblePriorIDs, tt.compatiblePriorIDs) {
+				t.Fatalf("CompatiblePriorIDs = %#v, want %#v", definition.CompatiblePriorIDs, tt.compatiblePriorIDs)
+			}
+			for _, id := range tt.compatiblePriorIDs {
+				if !definition.CompatibleWithPrior(id) {
+					t.Fatalf("CompatibleWithPrior(%q) = false, want true", id)
+				}
+			}
+		})
+	}
+}
+
 func TestResolvedMetadata(t *testing.T) {
 	location := mustLoadLocation(t)
 	resolved, err := Resolve(DailyToday, ResolveRequest{Now: mustParse("2026-05-29T05:00:00-05:00"), Location: location})

internal/report/registry.go

@@ -13,7 +13,10 @@ func DefaultRegistry() Registry {
 			Name:               "Daily Report",
 			PromptID:           "weather.daily_report",
 			ComparisonStrategy: CompareSameValidDate,
-			DefaultOutputName:  "daily.md",
+			ArtifactGroup:      "daily",
+			BatchOutputName:    "daily.md",
+			Generated:          true,
+			CompatiblePriorIDs: []ID{DailyToday, DailyTomorrow},
 			Morning:            true,
 			resolve:            resolveDailyToday,
 		},
@@ -22,7 +25,10 @@ func DefaultRegistry() Registry {
 			Name:               "Tomorrow Planning Brief",
 			PromptID:           "weather.daily_report",
 			ComparisonStrategy: CompareSameValidDate,
-			DefaultOutputName:  "tomorrow.md",
+			ArtifactGroup:      "daily",
+			BatchOutputName:    "tomorrow.md",
+			Generated:          true,
+			CompatiblePriorIDs: []ID{DailyToday, DailyTomorrow},
 			Evening:            true,
 			resolve:            resolveDailyTomorrow,
 		},
@@ -31,7 +37,10 @@ func DefaultRegistry() Registry {
 			Name:               "3-Day Outlook",
 			PromptID:           "weather.three_day_outlook",
 			ComparisonStrategy: CompareSameValidDate,
-			DefaultOutputName:  "three_day.md",
+			ArtifactGroup:      "three-day",
+			BatchOutputName:    "three-day.md",
+			Generated:          true,
+			CompatiblePriorIDs: []ID{ThreeDay},
 			Morning:            true,
 			resolve:            resolveThreeDay,
 		},
@@ -40,7 +49,10 @@ func DefaultRegistry() Registry {
 			Name:               "Weekend Outlook",
 			PromptID:           "weather.weekend_outlook",
 			ComparisonStrategy: CompareWeekendWindow,
-			DefaultOutputName:  "weekend.md",
+			ArtifactGroup:      "weekend",
+			BatchOutputName:    "weekend.md",
+			Generated:          true,
+			CompatiblePriorIDs: []ID{Weekend},
 			Morning:            true,
 			resolve:            resolveWeekend,
 		},
@@ -49,7 +61,10 @@ func DefaultRegistry() Registry {
 			Name:               "Storm Report",
 			PromptID:           "weather.storm_report",
 			ComparisonStrategy: CompareExplicitWindow,
-			DefaultOutputName:  "storm.md",
+			ArtifactGroup:      "storm",
+			BatchOutputName:    "storm.md",
+			Generated:          true,
+			CompatiblePriorIDs: []ID{Storm},
 			resolve:            resolveStorm,
 		},
 	}

internal/state/filesystem.go

@@ -10,9 +10,9 @@ import (
 	"strings"
 	"time"
 
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/scriptorium"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
+	"gitea.maximumdirect.net/eric/weatherreporter/internal/fileutil"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
 )
@@ -79,9 +79,9 @@ func (s *FilesystemStore) Paths(resolved report.Resolved) (ArtifactPaths, error)
 	if metadata.RunID == "" {
 		return ArtifactPaths{}, fmt.Errorf("run id is required")
 	}
-	group, err := reportGroup(resolved.Definition.ID)
-	if err != nil {
-		return ArtifactPaths{}, err
+	group := resolved.Definition.ArtifactGroup
+	if group == "" {
+		return ArtifactPaths{}, fmt.Errorf("report %q has no artifact group", resolved.Definition.ID)
 	}
 	validDate := resolved.ValidPeriod.Start.Format("2006-01-02")
 	filenameBase := metadata.RunID
@@ -99,7 +99,7 @@ func (s *FilesystemStore) SaveBriefing(_ context.Context, resolved report.Resolv
 	if err != nil {
 		return "", err
 	}
-	if err := writeJSONAtomic(paths.Briefing, pkg); err != nil {
+	if err := fileutil.WriteJSONAtomic(paths.Briefing, pkg); err != nil {
 		return "", err
 	}
 	return paths.Briefing, nil
@@ -113,21 +113,18 @@ func (s *FilesystemStore) SaveDataPackage(_ context.Context, resolved report.Res
 	if err := promptinput.Validate(pkg); err != nil {
 		return "", err
 	}
-	if err := writeJSONAtomic(paths.DataPackage, pkg); err != nil {
+	if err := fileutil.WriteJSONAtomic(paths.DataPackage, pkg); err != nil {
 		return "", err
 	}
 	return paths.DataPackage, nil
 }
 
-func (s *FilesystemStore) SavePreflight(_ context.Context, resolved report.Resolved, result *scriptorium.RenderResult) (string, error) {
-	if result == nil {
-		return "", fmt.Errorf("render result is required")
-	}
+func (s *FilesystemStore) SavePreflight(_ context.Context, resolved report.Resolved, artifact PreflightArtifact) (string, error) {
 	paths, err := s.Paths(resolved)
 	if err != nil {
 		return "", err
 	}
-	if err := writeJSONAtomic(paths.Preflight, result); err != nil {
+	if err := fileutil.WriteJSONAtomic(paths.Preflight, artifact); err != nil {
 		return "", err
 	}
 	return paths.Preflight, nil
@@ -157,27 +154,22 @@ func (s *FilesystemStore) SaveMetadata(_ context.Context, metadata Metadata) (st
 	if metadata.PreflightPath == "" {
 		return "", fmt.Errorf("metadata preflight path is required")
 	}
-	path := metadataPathFromStored(metadata)
-	if path == "" {
-		return "", fmt.Errorf("metadata path cannot be resolved")
+	if metadata.MetadataPath == "" {
+		return "", fmt.Errorf("metadata path is required")
 	}
-	if err := writeJSONAtomic(path, metadata); err != nil {
+	if err := fileutil.WriteJSONAtomic(metadata.MetadataPath, metadata); err != nil {
 		return "", err
 	}
-	return path, nil
-}
-
-func (s *FilesystemStore) FindPriorDailySnapshot(ctx context.Context, resolved report.Resolved) (*PriorSnapshot, error) {
-	return s.FindPriorSnapshot(ctx, resolved)
+	return metadata.MetadataPath, nil
 }
 
 func (s *FilesystemStore) FindPriorSnapshot(_ context.Context, resolved report.Resolved) (*PriorSnapshot, error) {
 	if resolved.Definition.ComparisonStrategy != report.CompareSameValidDate && resolved.Definition.ComparisonStrategy != report.CompareWeekendWindow {
 		return nil, nil
 	}
-	group, err := reportGroup(resolved.Definition.ID)
-	if err != nil {
-		return nil, err
+	group := resolved.Definition.ArtifactGroup
+	if group == "" {
+		return nil, fmt.Errorf("report %q has no artifact group", resolved.Definition.ID)
 	}
 	dirs, err := s.metadataDirectories(resolved, group)
 	if err != nil {
@@ -205,7 +197,7 @@ func (s *FilesystemStore) FindPriorSnapshot(_ context.Context, resolved report.R
 			if metadata.RunID == resolved.Metadata().RunID {
 				continue
 			}
-			if !compatiblePriorReport(group, metadata.ReportID, resolved.Definition.ID) {
+			if !resolved.Definition.CompatibleWithPrior(metadata.ReportID) {
 				continue
 			}
 			if !comparablePeriod(metadata, resolved) {
@@ -343,19 +335,6 @@ func (s *FilesystemStore) metadataDirectories(resolved report.Resolved, group st
 	return dirs, nil
 }
 
-func compatiblePriorReport(group string, prior report.ID, current report.ID) bool {
-	switch group {
-	case "daily":
-		return prior == report.DailyToday || prior == report.DailyTomorrow
-	case "three-day":
-		return prior == report.ThreeDay && current == report.ThreeDay
-	case "weekend":
-		return prior == report.Weekend && current == report.Weekend
-	default:
-		return false
-	}
-}
-
 func (s *FilesystemStore) join(parts ...string) string {
 	all := append([]string{s.root}, parts...)
 	return filepath.Join(all...)
@@ -375,48 +354,6 @@ func validateRelativeDir(name string, value string) error {
 	return nil
 }
 
-func reportGroup(id report.ID) (string, error) {
-	switch id {
-	case report.DailyToday, report.DailyTomorrow:
-		return "daily", nil
-	case report.ThreeDay:
-		return "three-day", nil
-	case report.Weekend:
-		return "weekend", nil
-	case report.Storm:
-		return "storm", nil
-	default:
-		return "", fmt.Errorf("unknown report %q", id)
-	}
-}
-
-func writeJSONAtomic(path string, value any) error {
-	data, err := json.MarshalIndent(value, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal %q: %w", path, err)
-	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return fmt.Errorf("create directory %q: %w", filepath.Dir(path), err)
-	}
-	tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")
-	if err != nil {
-		return fmt.Errorf("create temporary file for %q: %w", path, err)
-	}
-	tmpName := tmp.Name()
-	defer os.Remove(tmpName)
-	if _, err := tmp.Write(data); err != nil {
-		tmp.Close()
-		return fmt.Errorf("write temporary file for %q: %w", path, err)
-	}
-	if err := tmp.Close(); err != nil {
-		return fmt.Errorf("close temporary file for %q: %w", path, err)
-	}
-	if err := os.Rename(tmpName, path); err != nil {
-		return fmt.Errorf("save %q: %w", path, err)
-	}
-	return nil
-}
-
 func readJSON(path string, target any) error {
 	data, err := os.ReadFile(path)
 	if err != nil {
@@ -428,14 +365,6 @@ func readJSON(path string, target any) error {
 	return nil
 }
 
-func metadataPathFromStored(metadata Metadata) string {
-	if metadata.BriefingPath == "" {
-		return ""
-	}
-	filename := metadata.RunID + ".metadata.json"
-	return filepath.Join(filepath.Dir(metadata.BriefingPath), filename)
-}
-
 func sameValidDate(metadata Metadata, resolved report.Resolved) bool {
 	return metadata.ValidPeriod.Start.Format("2006-01-02") == resolved.ValidPeriod.Start.Format("2006-01-02")
 }

internal/state/filesystem_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 	"time"
 
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/scriptorium"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
@@ -56,7 +55,7 @@ func TestSaveArtifactsAndMetadataRoundTrip(t *testing.T) {
 	if err != nil {
 		t.Fatalf("SaveDataPackage() error = %v", err)
 	}
-	preflightPath, err := store.SavePreflight(context.Background(), resolved, &scriptorium.RenderResult{Stdout: `{"ok":true}`})
+	preflightPath, err := store.SavePreflight(context.Background(), resolved, PreflightArtifact{Stdout: `{"ok":true}`})
 	if err != nil {
 		t.Fatalf("SavePreflight() error = %v", err)
 	}
@@ -67,6 +66,17 @@ func TestSaveArtifactsAndMetadataRoundTrip(t *testing.T) {
 	if err := os.WriteFile(renderedReportPath, []byte("# Daily Report\n"), 0o600); err != nil {
 		t.Fatalf("write rendered report: %v", err)
 	}
+	var preflight PreflightArtifact
+	preflightData, err := os.ReadFile(preflightPath)
+	if err != nil {
+		t.Fatalf("read preflight: %v", err)
+	}
+	if err := json.Unmarshal(preflightData, &preflight); err != nil {
+		t.Fatalf("decode preflight: %v", err)
+	}
+	if preflight.Stdout != `{"ok":true}` {
+		t.Fatalf("preflight stdout = %q, want render stdout", preflight.Stdout)
+	}
 	paths, err := store.Paths(resolved)
 	if err != nil {
 		t.Fatalf("Paths() error = %v", err)
@@ -112,9 +122,49 @@ func TestSaveArtifactsAndMetadataRoundTrip(t *testing.T) {
 	if decoded.RenderedReportPath != renderedReportPath {
 		t.Fatalf("RenderedReportPath = %q, want %q", decoded.RenderedReportPath, renderedReportPath)
 	}
+	if decoded.Location == nil || decoded.Location.Name != "Brentwood" || decoded.Location.Timezone != "America/Chicago" {
+		t.Fatalf("metadata location = %#v, want briefing location", decoded.Location)
+	}
+	if strings.Contains(string(data), "MetadataPath") || strings.Contains(string(data), "metadataPath") {
+		t.Fatalf("metadata JSON includes runtime-only MetadataPath:\n%s", string(data))
+	}
 }
 
-func TestFindPriorDailySnapshot(t *testing.T) {
+func TestSaveMetadataUsesExplicitMetadataPath(t *testing.T) {
+	store := newTestStore(t)
+	resolved := resolveDailyAt(t, "2026-05-29T05:00:00-05:00")
+	briefingPackage := stateBriefingPackage(resolved)
+	paths, err := store.Paths(resolved)
+	if err != nil {
+		t.Fatalf("Paths() error = %v", err)
+	}
+	otherDir := filepath.Join(t.TempDir(), "other-artifacts")
+	otherBriefingPath := filepath.Join(otherDir, resolved.Metadata().RunID+".briefing.json")
+	derivedMetadataPath := filepath.Join(otherDir, resolved.Metadata().RunID+".metadata.json")
+
+	metadata := BuildMetadata(resolved, briefingPackage, ArtifactPaths{
+		Briefing:       otherBriefingPath,
+		Metadata:       paths.Metadata,
+		DataPackage:    paths.DataPackage,
+		Preflight:      paths.Preflight,
+		RenderedReport: paths.RenderedReport,
+	})
+	metadataPath, err := store.SaveMetadata(context.Background(), metadata)
+	if err != nil {
+		t.Fatalf("SaveMetadata() error = %v", err)
+	}
+	if metadataPath != paths.Metadata {
+		t.Fatalf("SaveMetadata() path = %q, want explicit metadata path %q", metadataPath, paths.Metadata)
+	}
+	if _, err := os.Stat(paths.Metadata); err != nil {
+		t.Fatalf("expected explicit metadata path %q: %v", paths.Metadata, err)
+	}
+	if _, err := os.Stat(derivedMetadataPath); !os.IsNotExist(err) {
+		t.Fatalf("derived metadata path stat error = %v, want not exist", err)
+	}
+}
+
+func TestFindPriorSnapshot(t *testing.T) {
 	store := newTestStore(t)
 	first := resolveDailyAt(t, "2026-05-29T05:00:00-05:00")
 	second := resolveDailyAt(t, "2026-05-29T08:00:00-05:00")
@@ -138,12 +188,12 @@ func TestFindPriorDailySnapshot(t *testing.T) {
 		t.Fatalf("SaveMetadata() error = %v", err)
 	}
 
-	prior, err := store.FindPriorDailySnapshot(context.Background(), second)
+	prior, err := store.FindPriorSnapshot(context.Background(), second)
 	if err != nil {
-		t.Fatalf("FindPriorDailySnapshot() error = %v", err)
+		t.Fatalf("FindPriorSnapshot() error = %v", err)
 	}
 	if prior == nil {
-		t.Fatal("FindPriorDailySnapshot() = nil, want prior snapshot")
+		t.Fatal("FindPriorSnapshot() = nil, want prior snapshot")
 	}
 	if prior.Metadata.RunID != first.Metadata().RunID {
 		t.Fatalf("RunID = %q, want %q", prior.Metadata.RunID, first.Metadata().RunID)
@@ -153,7 +203,7 @@ func TestFindPriorDailySnapshot(t *testing.T) {
 	}
 }
 
-func TestFindPriorDailySnapshotUsesValidDate(t *testing.T) {
+func TestFindPriorSnapshotUsesValidDate(t *testing.T) {
 	store := newTestStore(t)
 	previousDate := resolveDailyAt(t, "2026-05-28T05:00:00-05:00")
 	currentDate := resolveDailyAt(t, "2026-05-29T05:00:00-05:00")
@@ -177,12 +227,12 @@ func TestFindPriorDailySnapshotUsesValidDate(t *testing.T) {
 		t.Fatalf("SaveMetadata() error = %v", err)
 	}
 
-	prior, err := store.FindPriorDailySnapshot(context.Background(), currentDate)
+	prior, err := store.FindPriorSnapshot(context.Background(), currentDate)
 	if err != nil {
-		t.Fatalf("FindPriorDailySnapshot() error = %v", err)
+		t.Fatalf("FindPriorSnapshot() error = %v", err)
 	}
 	if prior != nil {
-		t.Fatalf("FindPriorDailySnapshot() = %#v, want nil for different valid date", prior)
+		t.Fatalf("FindPriorSnapshot() = %#v, want nil for different valid date", prior)
 	}
 }
 
@@ -390,7 +440,13 @@ func stateBriefingPackage(resolved report.Resolved) briefing.Package {
 			GeneratedAt:   resolved.GeneratedAt,
 			Units:         "us",
 			Timezone:      resolved.Timezone,
-			ValidPeriod:   resolved.ValidPeriod,
+			Location: &briefing.LocationContext{
+				ID:       "home",
+				Name:     "Brentwood",
+				Region:   "St. Louis Metro",
+				Timezone: resolved.Timezone,
+			},
+			ValidPeriod: resolved.ValidPeriod,
 		},
 		Daily: &briefing.Daily{ForecastSummaryDate: "2026-05-29"},
 	}

internal/state/metadata.go

@@ -14,12 +14,14 @@ const MetadataSchemaVersion = "weatherreporter.metadata.v1"
 type Metadata struct {
 	SchemaVersion      string                    `json:"schemaVersion"`
 	RunID              string                    `json:"runId"`
+	MetadataPath       string                    `json:"-"`
 	ReportID           report.ID                 `json:"reportId"`
 	Variant            string                    `json:"variant,omitempty"`
 	PromptID           string                    `json:"promptId"`
 	GeneratedAt        time.Time                 `json:"generatedAt"`
 	Timezone           string                    `json:"timezone"`
 	ValidPeriod        timeutil.Period           `json:"validPeriod"`
+	Location           *briefing.LocationContext `json:"location,omitempty"`
 	SourceLocationID   string                    `json:"sourceLocationId,omitempty"`
 	SourceLocation     string                    `json:"sourceLocation,omitempty"`
 	Sources            []briefing.SourceMetadata `json:"sources,omitempty"`
@@ -35,12 +37,14 @@ func BuildMetadata(resolved report.Resolved, briefingPackage briefing.Package, p
 	return Metadata{
 		SchemaVersion:      MetadataSchemaVersion,
 		RunID:              metadata.RunID,
+		MetadataPath:       paths.Metadata,
 		ReportID:           metadata.ReportID,
 		Variant:            briefingPackage.Metadata.Variant,
 		PromptID:           metadata.PromptID,
 		GeneratedAt:        metadata.GeneratedAt,
 		Timezone:           metadata.Timezone,
 		ValidPeriod:        metadata.ValidPeriod,
+		Location:           copyLocation(briefingPackage.Metadata.Location),
 		SourceLocationID:   briefingPackage.Metadata.SourceLocationID,
 		SourceLocation:     briefingPackage.Metadata.SourceLocation,
 		Sources:            briefingPackage.Metadata.Sources,
@@ -51,3 +55,11 @@ func BuildMetadata(resolved report.Resolved, briefingPackage briefing.Package, p
 		RenderedReportPath: paths.RenderedReport,
 	}
 }
+
+func copyLocation(location *briefing.LocationContext) *briefing.LocationContext {
+	if location == nil {
+		return nil
+	}
+	copied := *location
+	return &copied
+}

internal/state/store.go

@@ -4,7 +4,6 @@ package state
 import (
 	"context"
 
-	"gitea.maximumdirect.net/eric/weatherreporter/internal/adapters/scriptorium"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
 	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
@@ -14,11 +13,10 @@ type Store interface {
 	Paths(report.Resolved) (ArtifactPaths, error)
 	SaveBriefing(context.Context, report.Resolved, briefing.Package) (string, error)
 	SaveDataPackage(context.Context, report.Resolved, promptinput.Package) (string, error)
-	SavePreflight(context.Context, report.Resolved, *scriptorium.RenderResult) (string, error)
+	SavePreflight(context.Context, report.Resolved, PreflightArtifact) (string, error)
 	PrepareRenderedReport(context.Context, report.Resolved) (string, error)
 	SaveMetadata(context.Context, Metadata) (string, error)
 	FindPriorSnapshot(context.Context, report.Resolved) (*PriorSnapshot, error)
-	FindPriorDailySnapshot(context.Context, report.Resolved) (*PriorSnapshot, error)
 	LoadBriefing(context.Context, string) (briefing.Package, error)
 }
 
@@ -26,3 +24,12 @@ type PriorSnapshot struct {
 	Metadata     Metadata
 	BriefingPath string
 }
+
+type PreflightArtifact struct {
+	Command         []string `json:"command"`
+	Stdout          string   `json:"stdout"`
+	Stderr          string   `json:"stderr"`
+	StdoutTruncated bool     `json:"stdoutTruncated,omitempty"`
+	StderrTruncated bool     `json:"stderrTruncated,omitempty"`
+	ExitCode        int      `json:"exitCode"`
+}