diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index 4585afd..68d6006 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -160,6 +160,15 @@ or mutate its completed result to make derived artifacts appear. ## Stage 3: Complete session defaults within ConfigKit's lifecycle +**Completed.** Session loads receive selected-campaign defaults and record them +before handoff, retaining their actual native result and source inventory. +Concrete-session checks run in definition validation; typed identity assertions +remain explicit. Stable input references are derived without mutating loaded +values, and standalone rendering preserves explicit optional-input clearing. +Session/default/import/discovery, preparation, initialization, native boundary, +and build checks pass with Go 1.27.4. The two catalog dependency tests noted in +Stage 2 remain pending Stage 4. + Read: `internal/config/document_configkit.go`, `load.go` and `mergeCampaignSession`, `document_render.go`, campaign/session validation, and ConfigKit's resolution recording and presence contracts. diff --git a/internal/app/command_outcome.go b/internal/app/command_outcome.go index ed9b703..75c94a1 100644 --- a/internal/app/command_outcome.go +++ b/internal/app/command_outcome.go @@ -1,6 +1,7 @@ package app import ( + "gitea.maximumdirect.net/eric/narratio/internal/config" "go.maximumdirect.net/ckconfig" "go.maximumdirect.net/commandkit" ) @@ -22,7 +23,8 @@ func operationOutcome(err error) commandkit.Outcome { } func classifyOperationError(err error) commandkit.OutcomeKind { - if _, ok := err.(*inputError); ok { + switch err.(type) { + case *inputError, *config.SessionIdentityError: return commandkit.OutcomeUsage } switch wrapped := err.(type) { diff --git a/internal/app/commands_boundary_test.go b/internal/app/commands_boundary_test.go index 2800b32..0314113 100644 --- a/internal/app/commands_boundary_test.go +++ b/internal/app/commands_boundary_test.go @@ -92,6 +92,7 @@ func TestOperationOutcomePreservesCausesAndOperationalPrecedence(t *testing.T) { status int }{ {nil, 0}, {input, 2}, {invalid, 2}, + {&config.SessionIdentityError{Source: "session.yml", Field: "session_id", Expected: "one", Actual: "two"}, 2}, {fmt.Errorf("request: %w", errors.Join(input, invalid)), 2}, {errors.Join(input, operational), 1}, {fmt.Errorf("request: %w", errors.Join(invalid, context.Canceled)), 1}, diff --git a/internal/app/config_loader.go b/internal/app/config_loader.go index f57a69e..9bffbb7 100644 --- a/internal/app/config_loader.go +++ b/internal/app/config_loader.go @@ -54,6 +54,9 @@ func loadCommandConfigWithDependencies(ctx context.Context, pipelineFlag, campai return nil, err } + sessionOpts.Campaign = base.Campaign + sessionOpts.CampaignPath = base.CampaignPath + if explicitSession := strings.TrimSpace(sessionFlag); explicitSession != "" { cfg, err := config.LoadSessionWithPipelineCampaignOptions(*base, explicitSession, sessionOpts) if err != nil { diff --git a/internal/app/operator_session_init.go b/internal/app/operator_session_init.go index 8c8381f..32060fd 100644 --- a/internal/app/operator_session_init.go +++ b/internal/app/operator_session_init.go @@ -97,6 +97,8 @@ func sessionInitWithDependencies(ctx context.Context, args []string, out io.Writ authoringPath = resolveSessionInitTemplatePath(input.CampaignPath, input.TemplateFile) } sessionCfg, err := config.LoadSessionAuthoringBytes(authoringPath, data, config.SessionLoadOptions{ + Campaign: base.Campaign, + CampaignPath: base.CampaignPath, SessionID: sessionID, PreviousSessionID: previousSessionID, }) diff --git a/internal/app/session_init_context_test.go b/internal/app/session_init_context_test.go index 5b63ecb..a7e5fc7 100644 --- a/internal/app/session_init_context_test.go +++ b/internal/app/session_init_context_test.go @@ -28,7 +28,7 @@ func TestSessionInitMaterializesLocalTemplateImports(t *testing.T) { if err != nil { t.Fatal(err) } - if loaded.Title != "Shared metadata" || loaded.Inputs.SpeakersFile != "" { + if loaded.Title != "Shared metadata" || loaded.Inputs.SpeakersFile != filepath.Join(filepath.Dir(campaign), "speakers.yml") { t.Fatalf("unexpected standalone session: %#v", loaded) } } diff --git a/internal/config/campaign_config_test.go b/internal/config/campaign_config_test.go index 1d352fd..25c805c 100644 --- a/internal/config/campaign_config_test.go +++ b/internal/config/campaign_config_test.go @@ -225,7 +225,7 @@ func TestCampaignSessionMismatchFails(t *testing.T) { if err == nil { t.Fatal("expected load error, got nil") } - if !strings.Contains(err.Error(), "does not match campaign config") { + if !strings.Contains(err.Error(), "campaign mismatch") { t.Fatalf("error = %q, want campaign mismatch context", err.Error()) } } diff --git a/internal/config/document_configkit.go b/internal/config/document_configkit.go index 18a27c7..470672d 100644 --- a/internal/config/document_configkit.go +++ b/internal/config/document_configkit.go @@ -26,6 +26,20 @@ func (cfg *CampaignConfig) ConfigKitResult() *configkit.Result[CampaignConfig] { return cfg.resolution.campaign } +// ConfigKitResult returns the session's actual completed native load result. +// Constructed session values have no result. +func (cfg *SessionConfig) ConfigKitResult() *configkit.Result[SessionConfig] { + if cfg == nil || cfg.resolution == nil { + return nil + } + return cfg.resolution.session +} + +func sessionFieldExplicit(cfg *SessionConfig, name string) bool { + result := cfg.ConfigKitResult() + return result != nil && result.Metadata().IsExplicit(configkit.Keys("inputs", name)) +} + func documentResource(resolution *configkit.Resolution, path configkit.Path, value *string, invocationDir string, sources map[string]string) { if info, ok := resolution.EntryInfo(path); ok && len(info.Origin.Locations) == 1 { if source, ok := resolution.Source(info.Origin.Locations[0].SourceID); ok { @@ -57,8 +71,14 @@ func campaignDefinition(invocationDir string, sources map[string]string) configk }, Validate: validateCampaignConfigKit} } -func sessionDefinition(invocationDir string, sources map[string]string) configkit.Definition[SessionConfig] { +func sessionDefinition(invocationDir string, sources map[string]string, label string, opts SessionLoadOptions) configkit.Definition[SessionConfig] { + hasSource := false return configkit.Definition[SessionConfig]{Resolve: func(cfg *SessionConfig, resolution *configkit.Resolution) error { + info, ok := resolution.EntryInfo(configkit.Keys()) + hasSource = ok && len(info.Origin.Locations) > 0 + if !hasSource { + return nil + } inputs := configkit.Keys("inputs") for _, field := range []struct { name string @@ -73,10 +93,51 @@ func sessionDefinition(invocationDir string, sources map[string]string) configki for index := range cfg.Inputs.AudioFiles { documentResource(resolution, inputs.Key("audio_files").Index(index), &cfg.Inputs.AudioFiles[index], invocationDir, sources) } + applyCampaignSessionDefaults(cfg, resolution, opts) return nil + }, Validate: func(cfg *SessionConfig, validation *configkit.Validation) { + // Optional discovery with no selected document leaves acquisition to + // the caller's next source. There is no session to validate yet. + if !hasSource { + return + } + data, err := json.Marshal(cfg) + if err != nil { + validation.Error(configkit.Keys(), "cannot inspect session configuration") + return + } + if err := rejectSessionTemplatePlaceholders(label, string(data)); err != nil { + validation.Error(configkit.Keys(), err.Error()) + return + } + if path, err := sessionConfigurationError(cfg); err != nil { + validation.Error(path, err.Error()) + } }} } +func applyCampaignSessionDefaults(cfg *SessionConfig, resolution *configkit.Resolution, opts SessionLoadOptions) { + if opts.Campaign == nil { + return + } + campaign := opts.Campaign + reason := fmt.Sprintf("default from campaign %q (%s)", CampaignID(campaign), opts.CampaignPath) + configkit.Default(resolution, configkit.Keys("campaign"), &cfg.Campaign, CampaignID(campaign), reason) + for _, field := range []struct { + name, value string + target *string + }{ + {"speakers_file", campaign.Inputs.SpeakersFile, &cfg.Inputs.SpeakersFile}, + {"autocorrect_file", campaign.Inputs.AutocorrectFile, &cfg.Inputs.AutocorrectFile}, + {"glossary_file", campaign.Inputs.GlossaryFile, &cfg.Inputs.GlossaryFile}, + {"spell_catalog_file", campaign.Inputs.SpellCatalogFile, &cfg.Inputs.SpellCatalogFile}, + } { + if field.value != "" { + configkit.Default(resolution, configkit.Keys("inputs", field.name), field.target, field.value, reason) + } + } +} + func loadCampaignWithConfigKit(path string) (*CampaignConfig, error) { invocationDir, err := os.Getwd() if err != nil { @@ -117,7 +178,7 @@ func loadSessionSourceWithFilesystem(source configkit.Source, label string, opts invocationDir = filesystem.BaseDir } sources := make(map[string]string) - result, err := configkit.Load(source, configkit.Options[SessionConfig]{Imports: imports, Filesystem: filesystem, Definition: sessionDefinition(invocationDir, sources)}) + result, err := configkit.Load(source, configkit.Options[SessionConfig]{Imports: imports, Filesystem: filesystem, Definition: sessionDefinition(invocationDir, sources, label, opts)}) if err != nil { return nil, "", describeConfigKitLoadError("session", err) } @@ -129,19 +190,12 @@ func loadSessionSourceWithFilesystem(source configkit.Source, label string, opts if selected == "" { selected = label } - cfg := result.Config - data, err := json.Marshal(cfg) - if err != nil { - return nil, "", fmt.Errorf("inspect session config: %w", err) - } - if err := rejectSessionTemplatePlaceholders(selected, string(data)); err != nil { - return nil, "", fmt.Errorf("load session config: %w", err) - } - if err := validateSessionIdentity(selected, &cfg, opts); err != nil { + cfg := &result.Config + if err := validateSessionIdentity(selected, cfg, opts); err != nil { return nil, "", err } cfg.resolution = &documentResolution{session: result, sources: sources} - return &cfg, filepath.Clean(selected), nil + return cfg, filepath.Clean(selected), nil } // DiscoverSession loads the first selected local candidate, or returns nil when diff --git a/internal/config/document_imports_test.go b/internal/config/document_imports_test.go index abba33d..dba4240 100644 --- a/internal/config/document_imports_test.go +++ b/internal/config/document_imports_test.go @@ -42,18 +42,18 @@ inputs: t.Fatalf("audio[%d] = %q", i, got) } } - if cfg.SessionDocument.Inputs.GlossaryFile != "" || cfg.SessionDocument.Inputs.SpeakersFile != filepath.Join(dir, "session/override.yml") { - t.Fatalf("detached session = %#v", cfg.SessionDocument) + if cfg.SessionDocument.Inputs.GlossaryFile != filepath.Join(dir, "campaign/glossary.yml") || cfg.SessionDocument.Inputs.SpeakersFile != filepath.Join(dir, "session/override.yml") { + t.Fatalf("completed session = %#v", cfg.SessionDocument) } if cfg.CampaignDocument.Inputs.GlossaryFile != filepath.Join(dir, "campaign/glossary.yml") { - t.Fatalf("detached campaign = %#v", cfg.CampaignDocument) + t.Fatalf("completed campaign = %#v", cfg.CampaignDocument) } } func TestSessionDiscoveryDistinguishesAbsenceFromInvalidSelection(t *testing.T) { dir := t.TempDir() first := filepath.Join(dir, "first.yml") - second := writePipelineFixture(t, dir, "second.yml", "session_id: valid\n") + second := writePipelineFixture(t, dir, "second.yml", "session_id: valid\n"+standaloneSessionFields) if cfg, path, err := DiscoverSession([]string{first, second}, SessionLoadOptions{}); err != nil || cfg == nil || path != second { t.Fatalf("selected = %#v %q %v", cfg, path, err) } @@ -86,7 +86,7 @@ func TestRemoteSessionResourceBaseIgnoresDiagnosticLabel(t *testing.T) { t.Fatal(err) } for _, label := range []string{"s3://bucket/session.yml", filepath.Join(t.TempDir(), "download.yml")} { - cfg, err := LoadSessionBytesWithOptions(label, []byte("session_id: test\ninputs: {audio_dir: ./audio}\n"), SessionLoadOptions{}) + cfg, err := LoadSessionBytesWithOptions(label, []byte("session_id: test\n"+standaloneSessionFields), SessionLoadOptions{}) if err != nil { t.Fatal(err) } @@ -110,7 +110,7 @@ func TestEquivalentDocumentLayoutsRenderIdentically(t *testing.T) { if err != nil { t.Fatal(err) } - session, err := LoadSession(files[1]) + session, err := LoadSessionWithOptions(files[1], SessionLoadOptions{Campaign: campaign, CampaignPath: files[0]}) if err != nil { t.Fatal(err) } diff --git a/internal/config/document_render.go b/internal/config/document_render.go index 2054c41..3401095 100644 --- a/internal/config/document_render.go +++ b/internal/config/document_render.go @@ -56,8 +56,11 @@ func RenderSessionDocument(cfg *Config, sessionID string) ([]byte, error) { SpeakersFile string `yaml:"speakers_file,omitempty"` AutocorrectFile string `yaml:"autocorrect_file,omitempty"` GlossaryFile string `yaml:"glossary_file,omitempty"` - SpellCatalogFile string `yaml:"spell_catalog_file,omitempty"` - }{doc.Inputs.AudioDir, doc.Inputs.AudioFiles, doc.Inputs.AudioS3, doc.Inputs.SpeakersFile, doc.Inputs.AutocorrectFile, doc.Inputs.GlossaryFile, doc.Inputs.SpellCatalogFile} + SpellCatalogFile *string `yaml:"spell_catalog_file,omitempty"` + }{doc.Inputs.AudioDir, doc.Inputs.AudioFiles, doc.Inputs.AudioS3, doc.Inputs.SpeakersFile, doc.Inputs.AutocorrectFile, doc.Inputs.GlossaryFile, nil} + if doc.Inputs.SpellCatalogFile != "" || sessionFieldExplicit(doc, "spell_catalog_file") { + inputs.SpellCatalogFile = &doc.Inputs.SpellCatalogFile + } value := struct { SessionID string `yaml:"session_id"` PreviousSessionID string `yaml:"previous_session_id,omitempty"` diff --git a/internal/config/load.go b/internal/config/load.go index 16de5b0..9fc325c 100644 --- a/internal/config/load.go +++ b/internal/config/load.go @@ -4,7 +4,6 @@ import ( "fmt" "path/filepath" "regexp" - "slices" "sort" "strings" @@ -69,8 +68,10 @@ func LoadSession(path string) (*SessionConfig, error) { return LoadSessionWithOptions(path, SessionLoadOptions{}) } -// SessionLoadOptions configures expected session identity checks. +// SessionLoadOptions supplies campaign defaults and expected session identities. type SessionLoadOptions struct { + Campaign *CampaignConfig + CampaignPath string SessionID string PreviousSessionID string Overlay *string @@ -89,19 +90,35 @@ func LoadSessionBytesWithOptions(label string, data []byte, opts SessionLoadOpti return cfg, err } -func validateSessionIdentity(label string, cfg *SessionConfig, opts SessionLoadOptions) error { - if strings.TrimSpace(opts.SessionID) != "" && strings.TrimSpace(cfg.SessionID) != "" && strings.TrimSpace(cfg.SessionID) != strings.TrimSpace(opts.SessionID) { - return fmt.Errorf("load session config: session file %q: session_id mismatch: --session-id %q does not match session_id %q", label, strings.TrimSpace(opts.SessionID), strings.TrimSpace(cfg.SessionID)) +// SessionIdentityError identifies an explicit identity assertion that the +// completed session configuration does not satisfy. +type SessionIdentityError struct { + Source string + Field string + Expected string + Actual string +} + +func (e *SessionIdentityError) Error() string { + if e.Actual == "" { + return fmt.Sprintf("load session config: session file %q: %s is required when %q is selected", e.Source, e.Field, e.Expected) } - if expected := strings.TrimSpace(opts.PreviousSessionID); expected != "" { - actual := strings.TrimSpace(cfg.PreviousSessionID) - if actual == "" { - return fmt.Errorf("load session config: session file %q: previous_session_id is required when --previous-session-id %q is provided", label, expected) - } - if actual != expected { - return fmt.Errorf("load session config: session file %q: previous_session_id mismatch: --previous-session-id %q does not match previous_session_id %q", label, expected, actual) + return fmt.Sprintf("load session config: session file %q: %s mismatch: selected %q does not match %q", e.Source, e.Field, e.Expected, e.Actual) +} + +func validateSessionIdentity(label string, cfg *SessionConfig, opts SessionLoadOptions) error { + for _, assertion := range []struct{ field, expected, actual string }{ + {"session_id", opts.SessionID, cfg.SessionID}, + {"previous_session_id", opts.PreviousSessionID, cfg.PreviousSessionID}, + } { + expected := strings.TrimSpace(assertion.expected) + if expected != "" && strings.TrimSpace(assertion.actual) != expected { + return &SessionIdentityError{Source: label, Field: assertion.field, Expected: expected, Actual: assertion.actual} } } + if opts.Campaign != nil && cfg.Campaign != CampaignID(opts.Campaign) { + return &SessionIdentityError{Source: label, Field: "campaign", Expected: CampaignID(opts.Campaign), Actual: cfg.Campaign} + } return nil } @@ -192,6 +209,8 @@ func LoadPipelineCampaignWithParty(pipelinePath string, pipeline *PipelineConfig // LoadSessionWithPipelineCampaignOptions loads one local session and combines // it with an already loaded pipeline and campaign. func LoadSessionWithPipelineCampaignOptions(loaded LoadedPipelineCampaign, sessionPath string, sessionOpts SessionLoadOptions) (*Config, error) { + sessionOpts.Campaign = loaded.Campaign + sessionOpts.CampaignPath = loaded.CampaignPath sessionCfg, err := LoadSessionWithOptions(sessionPath, sessionOpts) if err != nil { return nil, err @@ -230,20 +249,13 @@ func ResolveLoadedPipelineCampaign(loaded LoadedPipelineCampaign, sessionPath st SessionSource: sessionSource, Party: loaded.Party, } - campaignDocument := *loaded.Campaign - cfg.CampaignDocument = &campaignDocument + cfg.CampaignDocument = loaded.Campaign + cfg.SessionDocument = sessionCfg if sessionCfg == nil { return cfg, nil } - sessionDocument := *sessionCfg - sessionDocument.Inputs.AudioFiles = slices.Clone(sessionCfg.Inputs.AudioFiles) - if sessionCfg.Inputs.AudioS3 != nil { - audio := *sessionCfg.Inputs.AudioS3 - sessionDocument.Inputs.AudioS3 = &audio - } - cfg.SessionDocument = &sessionDocument - stableInputs, err := mergeCampaignSession(loaded.Campaign, sessionCfg, loaded.CampaignPath, sessionPath) + stableInputs, err := deriveStableInputs(loaded.Campaign, sessionCfg, loaded.CampaignPath, sessionPath) if err != nil { return nil, err } @@ -284,86 +296,44 @@ func campaignSessionPaths(paths ...string) (campaignPath, sessionPath string, er return campaignPath, sessionPath, nil } -func mergeCampaignSession(campaignCfg *CampaignConfig, sessionCfg *SessionConfig, campaignPath, sessionPath string) (ResolvedStableInputs, error) { +func deriveStableInputs(campaignCfg *CampaignConfig, sessionCfg *SessionConfig, campaignPath, sessionPath string) (ResolvedStableInputs, error) { if campaignCfg == nil { return ResolvedStableInputs{}, fmt.Errorf("campaign config is required") } if sessionCfg == nil { return ResolvedStableInputs{}, fmt.Errorf("session config is required") } - if campaignCfg.Inputs.SpellCatalogFile != "" && strings.TrimSpace(campaignCfg.Inputs.SpellCatalogFile) == "" { - return ResolvedStableInputs{}, fmt.Errorf("campaign.inputs.spell_catalog_file must be non-empty when provided") - } - if sessionCfg.Inputs.SpellCatalogFile != "" && strings.TrimSpace(sessionCfg.Inputs.SpellCatalogFile) == "" { - return ResolvedStableInputs{}, fmt.Errorf("session.inputs.spell_catalog_file must be non-empty when provided") - } - - campaignName := CampaignID(campaignCfg) - sessionCampaign := strings.TrimSpace(sessionCfg.Campaign) - if sessionCampaign != "" && campaignName != "" && sessionCampaign != campaignName { - return ResolvedStableInputs{}, fmt.Errorf( - "campaign/session config invalid: session campaign %q does not match campaign config %q", - sessionCampaign, - campaignName, - ) - } - if sessionCampaign == "" { - sessionCfg.Campaign = campaignName - } - - stable := ResolvedStableInputs{ - SpeakersFile: selectStableInput( - campaignCfg.Inputs.SpeakersFile, - sessionCfg.Inputs.SpeakersFile, - campaignPath, - sessionPath, - ), - AutocorrectFile: selectStableInput( - campaignCfg.Inputs.AutocorrectFile, - sessionCfg.Inputs.AutocorrectFile, - campaignPath, - sessionPath, - ), - GlossaryFile: selectStableInput( - campaignCfg.Inputs.GlossaryFile, - sessionCfg.Inputs.GlossaryFile, - campaignPath, - sessionPath, - ), - PartyFile: selectStableInput( - campaignCfg.Inputs.PartyFile, - "", - campaignPath, - sessionPath, - ), - SpellCatalogFile: selectStableInput( - campaignCfg.Inputs.SpellCatalogFile, - sessionCfg.Inputs.SpellCatalogFile, - campaignPath, - sessionPath, - ), + if sessionCfg.Campaign != CampaignID(campaignCfg) { + return ResolvedStableInputs{}, &SessionIdentityError{Source: sessionPath, Field: "campaign", Expected: CampaignID(campaignCfg), Actual: sessionCfg.Campaign} } + stable := ResolvedStableInputs{} for _, field := range []struct { - name string - input *ResolvedInputFile + name, value string + target *ResolvedInputFile + campaignOnly bool }{ - {"speakers_file", &stable.SpeakersFile}, {"autocorrect_file", &stable.AutocorrectFile}, - {"glossary_file", &stable.GlossaryFile}, {"party_file", &stable.PartyFile}, - {"spell_catalog_file", &stable.SpellCatalogFile}, + {"speakers_file", sessionCfg.Inputs.SpeakersFile, &stable.SpeakersFile, false}, + {"autocorrect_file", sessionCfg.Inputs.AutocorrectFile, &stable.AutocorrectFile, false}, + {"glossary_file", sessionCfg.Inputs.GlossaryFile, &stable.GlossaryFile, false}, + {"party_file", campaignCfg.Inputs.PartyFile, &stable.PartyFile, true}, + {"spell_catalog_file", sessionCfg.Inputs.SpellCatalogFile, &stable.SpellCatalogFile, false}, } { - metadata := campaignCfg.resolution - if field.input.Source == "session_config" { - metadata = sessionCfg.resolution + reference := ResolvedInputFile{Path: field.value, ConfigPath: sessionPath, Source: "session_config"} + metadata := sessionCfg.resolution + fromCampaign := field.campaignOnly + if sessionCfg.ConfigKitResult() != nil && !sessionFieldExplicit(sessionCfg, field.name) { + fromCampaign = true + } + if fromCampaign { + reference.ConfigPath = campaignPath + reference.Source = "campaign_config" + metadata = campaignCfg.resolution } if metadata != nil && metadata.sources["/inputs/"+field.name] != "" { - field.input.ConfigPath = metadata.sources["/inputs/"+field.name] + reference.ConfigPath = metadata.sources["/inputs/"+field.name] } + *field.target = reference } - - sessionCfg.Inputs.SpeakersFile = stable.SpeakersFile.Path - sessionCfg.Inputs.AutocorrectFile = stable.AutocorrectFile.Path - sessionCfg.Inputs.GlossaryFile = stable.GlossaryFile.Path - sessionCfg.Inputs.SpellCatalogFile = stable.SpellCatalogFile.Path return stable, nil } @@ -375,21 +345,6 @@ func CampaignID(cfg *CampaignConfig) string { return strings.TrimSpace(cfg.CampaignID) } -func selectStableInput(campaignValue, sessionValue, campaignPath, sessionPath string) ResolvedInputFile { - if strings.TrimSpace(sessionValue) != "" { - return ResolvedInputFile{ - Path: sessionValue, - ConfigPath: sessionPath, - Source: "session_config", - } - } - return ResolvedInputFile{ - Path: campaignValue, - ConfigPath: campaignPath, - Source: "campaign_config", - } -} - var sessionTemplatePlaceholderPattern = regexp.MustCompile(`\{\{[^}]*\}\}`) var sessionTemplateVariablePattern = regexp.MustCompile(`\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}`) diff --git a/internal/config/party_resolution_test.go b/internal/config/party_resolution_test.go index a741118..65d15e1 100644 --- a/internal/config/party_resolution_test.go +++ b/internal/config/party_resolution_test.go @@ -117,7 +117,7 @@ func TestResolveAndLoadedCampaignShareCanonicalPartyResolution(t *testing.T) { if err != nil { t.Fatalf("LoadCampaign() error = %v", err) } - session, err := LoadSession(sessionPath) + session, err := LoadSessionWithOptions(sessionPath, SessionLoadOptions{Campaign: campaign, CampaignPath: campaignPath}) if err != nil { t.Fatalf("LoadSession() error = %v", err) } diff --git a/internal/config/session_defaults_test.go b/internal/config/session_defaults_test.go new file mode 100644 index 0000000..a08e1fb --- /dev/null +++ b/internal/config/session_defaults_test.go @@ -0,0 +1,122 @@ +package config + +import ( + "bytes" + "errors" + "path/filepath" + "reflect" + "strings" + "testing" + + configkit "go.maximumdirect.net/configkit" + "gopkg.in/yaml.v3" +) + +func TestSessionDefaultsCompleteBeforeNativeHandoff(t *testing.T) { + dir := t.TempDir() + pipeline := writePipelineFixture(t, dir, "pipeline.yml", "workspace: {root: work}\n") + campaign := writePipelineFixture(t, dir, "campaign.yml", "config:\n imports:\n - path: campaign/resources.yml\ncampaign_id: campaign\n") + fragment := writePipelineFixture(t, dir, "campaign/resources.yml", `inputs: + speakers_file: speakers.yml + autocorrect_file: autocorrect.yml + glossary_file: glossary.yml + party_file: party.yml + spell_catalog_file: spells.yml +`) + writePipelineFixture(t, dir, "campaign/party.yml", canonicalPartyFixture) + session := writePipelineFixture(t, dir, "session.yml", "config:\n imports:\n - path: session/resources.yml\nsession_id: session\n") + sessionFragment := writePipelineFixture(t, dir, "session/resources.yml", "inputs:\n audio_dir: audio\n speakers_file: override.yml\n spell_catalog_file: ''\n") + cfg, err := LoadWithSessionOptions(pipeline, campaign, session, SessionLoadOptions{SessionID: "session"}) + if err != nil { + t.Fatal(err) + } + result := cfg.Session.ConfigKitResult() + if result == nil || cfg.Session != &result.Config { + t.Fatal("session lost its actual native result") + } + if len(result.Sources()) != 2 { + t.Fatalf("session sources include unrelated campaign inputs: %+v", result.Sources()) + } + if cfg.Session.Campaign != "campaign" || cfg.Session.Inputs.GlossaryFile != filepath.Join(dir, "campaign/glossary.yml") || cfg.Session.Inputs.SpellCatalogFile != "" { + t.Fatalf("session defaults/explicit clearing: %+v", cfg.Session) + } + if cfg.StableInputs.GlossaryFile.Source != "campaign_config" || cfg.StableInputs.GlossaryFile.ConfigPath != fragment || cfg.StableInputs.SpeakersFile.ConfigPath != sessionFragment || cfg.StableInputs.SpellCatalogFile.Source != "session_config" { + t.Fatalf("stable input references: %+v", cfg.StableInputs) + } + explanation, ok := result.Explain(configkit.Keys("inputs", "glossary_file")) + if !ok || explanation.Origin.Layer != configkit.LayerResolution { + t.Fatalf("default origin: %+v", explanation) + } + found := false + for _, change := range explanation.History { + if strings.Contains(strings.Join(change.Reasons, " "), campaign) { + found = true + } + } + if !found { + t.Fatalf("default history lacks campaign context: %+v", explanation.History) + } + var shown bytes.Buffer + if err := result.WriteEffective(&shown); err != nil { + t.Fatal(err) + } + var decoded SessionConfig + if err := yaml.Unmarshal(shown.Bytes(), &decoded); err != nil { + t.Fatal(err) + } + if decoded.Campaign != cfg.Session.Campaign || !reflect.DeepEqual(decoded.Inputs, cfg.Session.Inputs) { + t.Fatal("native show and domain session differ") + } + before := shown.String() + if _, err := deriveStableInputs(cfg.Campaign, cfg.Session, campaign, session); err != nil { + t.Fatal(err) + } + shown.Reset() + if err := result.WriteEffective(&shown); err != nil { + t.Fatal(err) + } + if shown.String() != before { + t.Fatal("reference derivation changed native configuration") + } + materialized, err := RenderSessionDocument(cfg, "session") + if err != nil { + t.Fatal(err) + } + reloaded, err := LoadSessionBytesWithOptions("materialized", materialized, SessionLoadOptions{Campaign: cfg.Campaign, CampaignPath: campaign}) + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(reloaded.Inputs, cfg.Session.Inputs) { + t.Fatalf("standalone rendering lost effective values or explicit clearing: %s", materialized) + } +} + +func TestSessionDefaultsRespectExplicitEmptyInputsAndIdentity(t *testing.T) { + dir := t.TempDir() + campaignPath := writePipelineFixture(t, dir, "campaign.yml", "campaign_id: campaign\ninputs: {speakers_file: speakers.yml, autocorrect_file: autocorrect.yml, glossary_file: glossary.yml, party_file: party.yml}\n") + campaign, err := LoadCampaign(campaignPath) + if err != nil { + t.Fatal(err) + } + opts := SessionLoadOptions{Campaign: campaign, CampaignPath: campaignPath, SessionID: "session"} + for _, data := range []string{ + "session_id: session\ninputs: {audio_dir: audio, glossary_file: ''}\n", + "session_id: session\ncampaign: ''\ninputs: {audio_dir: audio}\n", + "session_id: session\ninputs: null\n", + } { + _, err := LoadSessionBytesWithOptions("session.yml", []byte(data), opts) + var native *configkit.LoadError + if !errors.As(err, &native) { + t.Fatalf("explicit invalid value did not retain a native validation failure: %v", err) + } + } + _, err = LoadSessionBytesWithOptions("session.yml", []byte("session_id: other\ninputs: {audio_dir: audio}\n"), opts) + var mismatch *SessionIdentityError + if !errors.As(err, &mismatch) || mismatch.Field != "session_id" || mismatch.Actual != "other" { + t.Fatalf("identity assertion was concealed by defaults: %v", err) + } + _, err = LoadSessionBytesWithOptions("session.yml", []byte("session_id: session\ncampaign: other\ninputs: {audio_dir: audio}\n"), opts) + if !errors.As(err, &mismatch) || mismatch.Field != "campaign" { + t.Fatalf("campaign assertion was concealed: %v", err) + } +} diff --git a/internal/config/session_template_test.go b/internal/config/session_template_test.go index 018814b..56a7c4d 100644 --- a/internal/config/session_template_test.go +++ b/internal/config/session_template_test.go @@ -116,11 +116,7 @@ inputs: func TestLoadSessionWithOptionsRequiresExpectedPreviousSession(t *testing.T) { dir := t.TempDir() sessionPath := filepath.Join(dir, "session.yml") - sessionYAML := `session_id: 2026-05-03 -campaign: sample-campaign -inputs: - audio_dir: ./audio -` + sessionYAML := "session_id: 2026-05-03\n" + standaloneSessionFields if err := os.WriteFile(sessionPath, []byte(sessionYAML), 0o644); err != nil { t.Fatalf("write session.yml: %v", err) } @@ -196,7 +192,7 @@ inputs: } func TestLoadSessionBytesWithOptionsStrictDecode(t *testing.T) { - cfg, err := LoadSessionBytesWithOptions("s3://bucket/session.yml", []byte("session_id: 2026-05-03\n"), SessionLoadOptions{}) + cfg, err := LoadSessionBytesWithOptions("s3://bucket/session.yml", []byte("session_id: 2026-05-03\n"+standaloneSessionFields), SessionLoadOptions{}) if err != nil { t.Fatalf("LoadSessionBytesWithOptions() error = %v", err) } @@ -214,7 +210,7 @@ func TestLoadSessionBytesWithOptionsStrictDecode(t *testing.T) { } func TestLoadSessionBytesWithOptionsMismatchFails(t *testing.T) { - _, err := LoadSessionBytesWithOptions("s3://bucket/session.yml", []byte("session_id: 2026-05-03\n"), SessionLoadOptions{SessionID: "2026-04-04"}) + _, err := LoadSessionBytesWithOptions("s3://bucket/session.yml", []byte("session_id: 2026-05-03\n"+standaloneSessionFields), SessionLoadOptions{SessionID: "2026-04-04"}) if err == nil { t.Fatal("expected mismatch error, got nil") } @@ -226,7 +222,7 @@ func TestLoadSessionBytesWithOptionsMismatchFails(t *testing.T) { func TestLoadSessionBytesWithOptionsRequiresExpectedPreviousSession(t *testing.T) { _, err := LoadSessionBytesWithOptions( "s3://bucket/session.yml", - []byte("session_id: 2026-05-03\n"), + []byte("session_id: 2026-05-03\n"+standaloneSessionFields), SessionLoadOptions{PreviousSessionID: "2026-04-26"}, ) if err == nil || !strings.Contains(err.Error(), "previous_session_id is required") { @@ -248,3 +244,13 @@ func assertConcreteSessionTemplateError(t *testing.T, err error, vars ...string) } } } + +// Minimal concrete session fields for tests that exercise source acquisition or +// identity assertions independently of campaign defaulting. +const standaloneSessionFields = `campaign: sample-campaign +inputs: + audio_dir: audio + speakers_file: speakers.yml + autocorrect_file: autocorrect.yml + glossary_file: glossary.yml +` diff --git a/internal/config/storage_publish_test.go b/internal/config/storage_publish_test.go index 6082dad..6981c3b 100644 --- a/internal/config/storage_publish_test.go +++ b/internal/config/storage_publish_test.go @@ -707,10 +707,9 @@ storage: pipelinePath, sessionPath := writeConfigFiles(t, pipelineYAML, tt.sessionYAML) cfg, err := Load(pipelinePath, sessionPath) - if err != nil { - t.Fatalf("Load() error = %v", err) + if err == nil { + err = Validate(cfg) } - err = Validate(cfg) if tt.wantErr != "" { if err == nil || !strings.Contains(err.Error(), tt.wantErr) { t.Fatalf("Validate() error = %v, want to contain %q", err, tt.wantErr) diff --git a/internal/config/validate_core.go b/internal/config/validate_core.go index d0d39e1..821b9eb 100644 --- a/internal/config/validate_core.go +++ b/internal/config/validate_core.go @@ -62,33 +62,38 @@ func validateCache(cfg CacheConfig) error { } func validateSession(cfg *SessionConfig) error { + _, err := sessionConfigurationError(cfg) + return err +} + +func sessionConfigurationError(cfg *SessionConfig) (configkit.Path, error) { if err := validateSessionIdentifier("session.session_id", cfg.SessionID, true); err != nil { - return err + return configkit.Keys("session_id"), err } if err := validateSessionIdentifier("session.previous_session_id", cfg.PreviousSessionID, false); err != nil { - return err + return configkit.Keys("previous_session_id"), err } if strings.TrimSpace(cfg.PreviousSessionID) != "" && strings.TrimSpace(cfg.PreviousSessionID) == strings.TrimSpace(cfg.SessionID) { - return fmt.Errorf("session.previous_session_id must not equal session.session_id") + return configkit.Keys("previous_session_id"), fmt.Errorf("session.previous_session_id must not equal session.session_id") } if strings.TrimSpace(cfg.Campaign) == "" { - return fmt.Errorf("session.campaign is required") + return configkit.Keys("campaign"), fmt.Errorf("session.campaign is required") } if err := pathsafe.ValidateOpaqueSegment(cfg.Campaign); err != nil { - return fmt.Errorf("session.campaign: %w", err) + return configkit.Keys("campaign"), fmt.Errorf("session.campaign: %w", err) } if strings.TrimSpace(cfg.Inputs.SpeakersFile) == "" { - return fmt.Errorf("session.inputs.speakers_file is required") + return configkit.Keys("inputs", "speakers_file"), fmt.Errorf("session.inputs.speakers_file is required") } if strings.TrimSpace(cfg.Inputs.AutocorrectFile) == "" { - return fmt.Errorf("session.inputs.autocorrect_file is required") + return configkit.Keys("inputs", "autocorrect_file"), fmt.Errorf("session.inputs.autocorrect_file is required") } if strings.TrimSpace(cfg.Inputs.GlossaryFile) == "" { - return fmt.Errorf("session.inputs.glossary_file is required") + return configkit.Keys("inputs", "glossary_file"), fmt.Errorf("session.inputs.glossary_file is required") } if cfg.Inputs.SpellCatalogFile != "" && strings.TrimSpace(cfg.Inputs.SpellCatalogFile) == "" { - return fmt.Errorf("session.inputs.spell_catalog_file must be non-empty when provided") + return configkit.Keys("inputs", "spell_catalog_file"), fmt.Errorf("session.inputs.spell_catalog_file must be non-empty when provided") } hasAudioDir := strings.TrimSpace(cfg.Inputs.AudioDir) != "" @@ -96,20 +101,20 @@ func validateSession(cfg *SessionConfig) error { hasAudioS3 := cfg.Inputs.AudioS3 != nil if hasAudioS3 { if strings.TrimSpace(cfg.Inputs.AudioS3.Prefix) == "" { - return fmt.Errorf("session.inputs.audio_s3.prefix is required when session.inputs.audio_s3 is configured") + return configkit.Keys("inputs", "audio_s3", "prefix"), fmt.Errorf("session.inputs.audio_s3.prefix is required when session.inputs.audio_s3 is configured") } if err := validateRelativeSafePath("session.inputs.audio_s3.prefix", cfg.Inputs.AudioS3.Prefix); err != nil { - return err + return configkit.Keys("inputs", "audio_s3", "prefix"), err } } if hasAudioS3 && (hasAudioDir || hasAudioFiles) { - return fmt.Errorf("session.inputs.audio_dir/audio_files and session.inputs.audio_s3 are mutually exclusive") + return configkit.Keys("inputs", "audio_dir"), fmt.Errorf("session.inputs.audio_dir/audio_files and session.inputs.audio_s3 are mutually exclusive") } if !hasAudioDir && !hasAudioFiles && !hasAudioS3 { - return fmt.Errorf("session.inputs requires audio_dir, at least one audio_files entry, or audio_s3") + return configkit.Keys("inputs"), fmt.Errorf("session.inputs requires audio_dir, at least one audio_files entry, or audio_s3") } - return nil + return configkit.Keys(), nil } func validateResolvedPartyInputs(cfg *Config) error { diff --git a/internal/stage/prepare_documents_test.go b/internal/stage/prepare_documents_test.go index 1410552..332c7a4 100644 --- a/internal/stage/prepare_documents_test.go +++ b/internal/stage/prepare_documents_test.go @@ -24,7 +24,7 @@ func TestPrepareMaterializesImportedDocumentsWithoutAuthoringFiles(t *testing.T) if err != nil { t.Fatal(err) } - session, err := config.LoadSession(env.Config.SessionPath) + session, err := config.LoadSessionWithOptions(env.Config.SessionPath, config.SessionLoadOptions{Campaign: campaign, CampaignPath: env.Config.CampaignPath}) if err != nil { t.Fatal(err) } @@ -62,7 +62,7 @@ func TestPrepareMaterializesImportedDocumentsWithoutAuthoringFiles(t *testing.T) t.Fatalf("prepared campaign = %#v, %v", preparedCampaign, err) } preparedSession, err := config.LoadSession(filepath.Join(paths.InputsDir, "session.yml")) - if err != nil || preparedSession.Title != "Imported title" || preparedSession.Inputs.SpeakersFile != "" { + if err != nil || preparedSession.Title != "Imported title" || preparedSession.Inputs.SpeakersFile != filepath.Join(dir, "speakers.yml") { t.Fatalf("prepared session = %#v, %v", preparedSession, err) } record := findManifestInput(t, m.Inputs, "session_config")