From 065a615e5f1c85e4cdec71fd06430e40b338a052 Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Fri, 20 Nov 2026 04:42:23 +0000 Subject: [PATCH] Use derived artifact catalogs throughout planning and execution --- docs/roadmap/implementation.md | 10 ++ internal/app/analyze_artifacts.go | 14 +- .../app/analyze_checkpoint_recovery_test.go | 5 +- internal/app/assembled_workflow_test.go | 3 +- internal/app/catalog_execution_test.go | 128 ++++++++++++++ internal/app/config_commands.go | 33 ++-- internal/app/config_commands_test.go | 2 +- internal/app/operator_artifact_rendering.go | 4 +- internal/app/restore_plan.go | 2 +- internal/app/restore_plan_test.go | 1 + internal/app/runner.go | 4 +- internal/app/runner_runtime.go | 9 +- internal/app/runner_test.go | 7 + internal/config/config.go | 9 + internal/stage/analyze.go | 21 +-- internal/stage/analyze_checkpoint_test.go | 6 +- internal/stage/analyze_failure_test.go | 6 +- internal/stage/analyze_family_origin_test.go | 2 +- internal/stage/analyze_fingerprint.go | 6 +- internal/stage/analyze_fingerprint_test.go | 10 +- .../analyze_incremental_execution_test.go | 10 +- internal/stage/analyze_input_identity_test.go | 10 +- internal/stage/analyze_plan.go | 19 +-- internal/stage/analyze_plan_test.go | 16 +- internal/stage/analyze_reconciliation.go | 4 +- internal/stage/analyze_reconciliation_test.go | 12 +- internal/stage/analyze_resume.go | 20 +-- internal/stage/analyze_resume_test.go | 23 +-- internal/stage/analyze_test.go | 159 +++++++++--------- internal/stage/prepare.go | 4 +- .../stage/prepare_effective_artifacts_test.go | 3 +- internal/stage/prepare_previous_test.go | 1 + internal/stage/prepare_test.go | 1 + internal/stage/publish.go | 2 +- internal/stage/publish_outputs.go | 7 +- internal/stage/publish_test.go | 9 +- 36 files changed, 377 insertions(+), 205 deletions(-) create mode 100644 internal/app/catalog_execution_test.go diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index 081a90b..3e5f8b8 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -233,6 +233,16 @@ selection reaches family members and players; collisions remain errors. ## Stage 5: Wire derived products through planning and execution +**Completed.** Analysis selection, planning, fingerprinting, reconciliation, +previous-session requirements, runtime registration, and artifact inspection use +the separate concrete catalog. Run options retain normalized family selection +and origins through the stage environment; Scriptorium requests borrow genuine +shared settings. An assembled bounded run verifies explicit-roster players, +family dependencies, adapter variables, durable identities, and unchanged native +configuration. Configuration, stage, and artifact suites, focused runner and +bounded-composition checks, and builds pass with Go 1.27.4. CLI tests awaiting +the later native command/inspection conversion remain transitional. + Read: `internal/app/analyze_artifacts.go`, `runner_runtime.go`, `bounded_prerequisites.go`, `internal/stage/stage.go`, `analyze*.go`, `trim.go`, and the artifact catalog/resolution owners. diff --git a/internal/app/analyze_artifacts.go b/internal/app/analyze_artifacts.go index 71ff8bd..1643cf6 100644 --- a/internal/app/analyze_artifacts.go +++ b/internal/app/analyze_artifacts.go @@ -59,7 +59,7 @@ func resolveEffectiveArtifacts(cfg *config.Config, selected []string) (artifacts } return artifacts.EffectiveArtifactSet{}, fmt.Errorf("--artifacts requires pipeline.scriptorium.artifacts to be configured") } - configured := artifacts.ConfiguredArtifactDefinitions(cfg.Pipeline.Scriptorium.Artifacts) + configured := artifacts.ConfiguredArtifactDefinitions(cfg.ConcreteArtifacts()) normalized, err := normalizeArtifactSelection(cfg, selected) if err != nil { return artifacts.EffectiveArtifactSet{}, err @@ -74,18 +74,18 @@ func resolveEffectiveArtifacts(cfg *config.Config, selected []string) (artifacts } return artifacts.EffectiveArtifactSet{}, err } - if err := validateEffectiveArtifactConfiguration(cfg.Pipeline.Scriptorium.Artifacts, effective); err != nil { + if err := validateEffectiveArtifactConfiguration(cfg.ConcreteArtifacts(), effective); err != nil { return artifacts.EffectiveArtifactSet{}, err } - return effective.WithOrigins(effectiveArtifactOrigins(cfg.Pipeline)), nil + return effective.WithOrigins(effectiveArtifactOrigins(cfg.ArtifactCatalog)), nil } func normalizeArtifactSelection(cfg *config.Config, selected []string) ([]string, error) { if len(selected) == 0 { return nil, nil } - configured := cfg.Pipeline.Scriptorium.Artifacts - families := config.ArtifactFamilies(cfg.Pipeline).Families + configured := cfg.ConcreteArtifacts() + families := config.ArtifactFamilies(cfg.ArtifactCatalog).Families set := make(map[string]struct{}, len(selected)) for _, raw := range selected { key := strings.TrimSpace(raw) @@ -111,8 +111,8 @@ func normalizeArtifactSelection(cfg *config.Config, selected []string) ([]string return normalized, nil } -func effectiveArtifactOrigins(pipeline *config.PipelineConfig) map[string]artifacts.EffectiveArtifactOrigin { - catalog := config.ArtifactFamilies(pipeline) +func effectiveArtifactOrigins(derived *config.ArtifactCatalog) map[string]artifacts.EffectiveArtifactOrigin { + catalog := config.ArtifactFamilies(derived) origins := make(map[string]artifacts.EffectiveArtifactOrigin, len(catalog.Members)) for key, member := range catalog.Members { origins[key] = artifacts.EffectiveArtifactOrigin{Family: member.Family, CharacterID: member.CharacterID} diff --git a/internal/app/analyze_checkpoint_recovery_test.go b/internal/app/analyze_checkpoint_recovery_test.go index f368217..073881a 100644 --- a/internal/app/analyze_checkpoint_recovery_test.go +++ b/internal/app/analyze_checkpoint_recovery_test.go @@ -20,6 +20,7 @@ import ( func TestExecuteStagesRetriesFromLastAnalyzeCheckpoint(t *testing.T) { cfg := testConfig(t) cfg.Pipeline.Scriptorium = &config.ScriptoriumConfig{Artifacts: checkpointRecoveryArtifacts("original")} + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: cfg.Pipeline.Scriptorium.Artifacts} store := &manifest.LocalStore{} seed := manifest.New(cfg.Session.SessionID, time.Now().UTC()) seed.Campaign = cfg.Session.Campaign @@ -47,7 +48,7 @@ func TestExecuteStagesRetriesFromLastAnalyzeCheckpoint(t *testing.T) { upstream := cloneStageRecords(baseline, "prepare", "transcribe", "merge", "polish", "normalize", "trim") unrelated := baseline.Stages["analyze"].AnalyzeArtifacts["unrelated"] - cfg.Pipeline.Scriptorium.Artifacts = checkpointRecoveryArtifacts("revised") + cfg.ArtifactCatalog.Artifacts = checkpointRecoveryArtifacts("revised") failure := errors.New("injected quest-log failure") failingRunner := &analyzeCheckpointRunner{FailPrompt: "quest-log-revised", Err: failure} if _, err := executeStages(context.Background(), cfg, []stage.Stage{analyze}, RunOptions{ @@ -106,6 +107,7 @@ func TestExecuteStagesJoinsAnalyzeFailureWithTerminalSaveFailure(t *testing.T) { "chronicle": {Enabled: true, PromptID: "chronicle", OutputPath: "artifacts/chronicle.md"}, }, } + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: cfg.Pipeline.Scriptorium.Artifacts} artifactErr := errors.New("injected analyze failure") terminalErr := errors.New("injected terminal save failure") store := &failedAnalyzeSaveStore{Store: &manifest.LocalStore{}, Err: terminalErr} @@ -131,6 +133,7 @@ func TestExecuteStagesPersistsAnalyzeCheckpointFailureRecovery(t *testing.T) { "quest_log": {Enabled: true, PromptID: "quest-log", OutputPath: "artifacts/quest_log.md"}, }, } + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: cfg.Pipeline.Scriptorium.Artifacts} baseStore := &manifest.LocalStore{} seed := manifest.New(cfg.Session.SessionID, time.Now().UTC()) seed.Campaign = cfg.Session.Campaign diff --git a/internal/app/assembled_workflow_test.go b/internal/app/assembled_workflow_test.go index a071cd3..0b06551 100644 --- a/internal/app/assembled_workflow_test.go +++ b/internal/app/assembled_workflow_test.go @@ -142,6 +142,7 @@ func TestAssembledLegacyAnalyzeTransitionPublishesOnlyCurrentRecords(t *testing. "player_handout": {Enabled: true, PromptID: "dnd.player_handout", OutputPath: "artifacts/player_handout.md"}, "session_recap": {Enabled: true, PromptID: "dnd.session_recap", OutputPath: "artifacts/session_recap.md"}, }} + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: cfg.Pipeline.Scriptorium.Artifacts} cfg.Pipeline.Storage.Backend = config.StorageBackendS3 cfg.Pipeline.Storage.S3 = &config.StorageS3Config{Bucket: "archive", RootPrefix: "dnd"} cfg.Pipeline.Publish = &config.PublishConfig{ @@ -202,7 +203,7 @@ func TestAssembledLegacyAnalyzeTransitionPublishesOnlyCurrentRecords(t *testing. t.Fatalf("legacy transition invalidated %s: %#v", transcriptStage, afterPartial.Stages[transcriptStage]) } } - configured := artifacts.ConfiguredArtifactDefinitions(cfg.Pipeline.Scriptorium.Artifacts) + configured := artifacts.ConfiguredArtifactDefinitions(cfg.ArtifactCatalog.Artifacts) effective, err := artifacts.ResolveEffectiveArtifactSet(configured, nil) if err != nil { t.Fatal(err) diff --git a/internal/app/catalog_execution_test.go b/internal/app/catalog_execution_test.go new file mode 100644 index 0000000..f90d0ed --- /dev/null +++ b/internal/app/catalog_execution_test.go @@ -0,0 +1,128 @@ +package app + +import ( + "bytes" + "context" + "encoding/json" + "io" + "log/slog" + "os" + "path/filepath" + "reflect" + "strings" + "testing" + "time" + + "gitea.maximumdirect.net/eric/narratio/internal/adapters/scriptorium" + "gitea.maximumdirect.net/eric/narratio/internal/artifactpolicy" + "gitea.maximumdirect.net/eric/narratio/internal/artifacts" + "gitea.maximumdirect.net/eric/narratio/internal/config" + "gitea.maximumdirect.net/eric/narratio/internal/manifest" +) + +func TestSelectedPartyCatalogDrivesBoundedAnalysis(t *testing.T) { + dir := t.TempDir() + pipelinePath := filepath.Join(dir, "pipeline.yml") + mustWriteTestFile(t, pipelinePath, `workspace: + root: `+filepath.Join(dir, "work")+` +scriptorium: + artifact_families: + character_meta: + enabled: false + for_each: party.characters + prompt_id: meta + output_path_pattern: artifacts/{character_id}/meta.md + inputs: + players: {source: narratio.input.players, required: true} + character_note: + enabled: false + for_each: party.characters + prompt_id: note + output_path_pattern: artifacts/{character_id}/note.md + inputs: + meta: {source: narratio.member_artifact.character_meta, required: true} + member_vars: + character_name: character.name +`) + campaignPath := filepath.Join(dir, "campaign.yml") + mustWriteTestFile(t, campaignPath, "campaign_id: campaign\ninputs: {speakers_file: speakers.yml, autocorrect_file: autocorrect.yml, glossary_file: glossary.yml, party_file: default-party.yml}\n") + partyPath := filepath.Join(dir, "selected-party.yml") + mustWriteTestFile(t, partyPath, "schema_version: narratio.party.v1\ncharacters:\n ivy:\n player: {name: Selected Player}\n character: {name: Ivy, classes: [{name: ranger}]}\n") + sessionPath := filepath.Join(dir, "session.yml") + mustWriteTestFile(t, sessionPath, "session_id: session\ninputs: {audio_dir: audio}\n") + pipeline, err := config.LoadPipeline(pipelinePath) + if err != nil { + t.Fatal(err) + } + campaign, err := config.LoadCampaign(campaignPath) + if err != nil { + t.Fatal(err) + } + loaded, err := config.LoadPipelineCampaignWithPartyFile(pipelinePath, pipeline, campaignPath, campaign, &partyPath) + if err != nil { + t.Fatal(err) + } + cfg, err := config.LoadSessionWithPipelineCampaignOptions(loaded, sessionPath, config.SessionLoadOptions{}) + if err != nil { + t.Fatal(err) + } + before, err := json.Marshal(cfg.Pipeline) + if err != nil { + t.Fatal(err) + } + plan, err := BuildBoundedPlan("analyze", "analyze") + if err != nil { + t.Fatal(err) + } + paths := artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root).SessionPathsFor("campaign", "session") + now := time.Now().UTC() + seed := manifest.New("session", now) + seed.Campaign = "campaign" + for _, name := range plan.PrefixNames() { + seed.MarkStageSucceeded(name, now, nil) + } + playersPath := filepath.Join(paths.InputsDir, "players.yml") + mustWriteTestFile(t, playersPath, string(cfg.Party.Players)) + checksum, err := artifacts.SHA256File(playersPath) + if err != nil { + t.Fatal(err) + } + descriptor, ok := artifactpolicy.DescribePreparedInputSource("narratio.input.players") + if !ok { + t.Fatal("players source is unavailable") + } + seed.Inputs = append(seed.Inputs, manifest.InputRecord{Kind: descriptor.ManifestKind, Path: playersPath, Checksum: checksum}) + saveBoundedManifest(t, cfg, seed) + runner := &scriptorium.FakeRunner{} + summary, err := executePlan(context.Background(), cfg, plan, RunOptions{ + SelectedArtifacts: []string{"character_note"}, + Env: &Env{Scriptorium: runner, Logger: slog.New(slog.NewTextHandler(io.Discard, nil))}, + }) + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(summary.Executed, []string{"analyze"}) || len(runner.RunRequests) != 2 || runner.RunRequests[0].PromptID != "meta" || runner.RunRequests[1].PromptID != "note" { + t.Fatalf("bounded family execution: summary=%+v requests=%+v", summary, runner.RunRequests) + } + players, err := os.ReadFile(runner.RunRequests[0].InputPaths["players"]) + if err != nil || !strings.Contains(string(players), "Selected Player") || runner.RunRequests[1].Vars["character_name"] != "Ivy" { + t.Fatalf("selected roster did not reach both domain consumers: %v", err) + } + current, err := (&manifest.LocalStore{}).Load(context.Background(), manifestPathFor(cfg)) + if err != nil { + t.Fatal(err) + } + for _, key := range []string{"character_meta_ivy", "character_note_ivy"} { + record := current.Stages["analyze"].AnalyzeArtifacts[key] + if record.Status != manifest.AnalyzeArtifactCurrent || record.CharacterID != "ivy" || record.Family == "" { + t.Fatalf("family output identity: %+v", record) + } + } + after, err := json.Marshal(cfg.Pipeline) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(before, after) || len(cfg.Pipeline.Scriptorium.Artifacts) != 0 { + t.Fatal("execution changed completed pipeline configuration") + } +} diff --git a/internal/app/config_commands.go b/internal/app/config_commands.go index 35199fd..cde3e42 100644 --- a/internal/app/config_commands.go +++ b/internal/app/config_commands.go @@ -22,11 +22,12 @@ type inspectionFlags struct { } type inspectionConfig struct { - PipelinePath string - Pipeline *config.PipelineConfig - CampaignPath string - Campaign *config.CampaignConfig - Party config.ResolvedParty + PipelinePath string + Pipeline *config.PipelineConfig + CampaignPath string + Campaign *config.CampaignConfig + Party config.ResolvedParty + ArtifactCatalog *config.ArtifactCatalog } // Config dispatches read-only pipeline configuration commands. @@ -166,10 +167,7 @@ func configArtifactsWithDependencies(_ context.Context, args []string, out io.Wr if err != nil { return fmt.Errorf("config artifacts: %w", err) } - records, err := config.EffectiveArtifactCatalog(resolved.Pipeline, resolved.Party) - if err != nil { - return fmt.Errorf("config artifacts: %w", err) - } + records := resolved.ArtifactCatalog.Records if _, err := fmt.Fprintln(out, "key\tsource\tdefinitions\tenabled\toutput\tdependencies\tfamily\tcharacter\tfamily_source\tparty_source"); err != nil { return err } @@ -254,7 +252,11 @@ func resolveInspectionConfigWithDependencies(flags inspectionFlags, deps command if err := validateInspectionPipeline(pipelinePath, pipeline); err != nil { return nil, err } - return &inspectionConfig{PipelinePath: pipelinePath, Pipeline: pipeline}, nil + catalog, err := config.DeriveArtifactCatalog(pipeline, config.ResolvedParty{}) + if err != nil { + return nil, err + } + return &inspectionConfig{PipelinePath: pipelinePath, Pipeline: pipeline, ArtifactCatalog: catalog}, nil } campaignPath, err := resolveCampaignConfigPath(pipeline, flags.campaignPath, flags.campaignFilePath) @@ -284,11 +286,12 @@ func resolveInspectionConfigWithDependencies(flags inspectionFlags, deps command return nil, err } return &inspectionConfig{ - PipelinePath: loaded.PipelinePath, - Pipeline: loaded.Pipeline, - CampaignPath: loaded.CampaignPath, - Campaign: loaded.Campaign, - Party: loaded.Party, + PipelinePath: loaded.PipelinePath, + Pipeline: loaded.Pipeline, + CampaignPath: loaded.CampaignPath, + Campaign: loaded.Campaign, + Party: loaded.Party, + ArtifactCatalog: loaded.ArtifactCatalog, }, nil } diff --git a/internal/app/config_commands_test.go b/internal/app/config_commands_test.go index a95da60..4b2b545 100644 --- a/internal/app/config_commands_test.go +++ b/internal/app/config_commands_test.go @@ -920,7 +920,7 @@ func TestNativeBundleInspectionAndExecutionAgree(t *testing.T) { if execution.Pipeline.Audita.ProposalProfile != "narratio-testing-model-placeholder" { t.Fatalf("execution did not use the inspected overlay: %q", execution.Pipeline.Audita.ProposalProfile) } - if _, ok := execution.Pipeline.Scriptorium.Artifacts["character_meta_arannis"]; !ok { + if _, ok := execution.ArtifactCatalog.Artifacts["character_meta_arannis"]; !ok { t.Fatal("execution did not expand the inspected party family") } } diff --git a/internal/app/operator_artifact_rendering.go b/internal/app/operator_artifact_rendering.go index cc03390..7f890fc 100644 --- a/internal/app/operator_artifact_rendering.go +++ b/internal/app/operator_artifact_rendering.go @@ -16,7 +16,7 @@ import ( func buildHelperArtifactCatalog(cfg *config.Config, m *manifest.Manifest) (*artifacts.ArtifactCatalog, error) { configured := artifacts.ConfiguredArtifactDefinitions(nil) if cfg.Pipeline.Scriptorium != nil { - configured = artifacts.ConfiguredArtifactDefinitions(cfg.Pipeline.Scriptorium.Artifacts) + configured = artifacts.ConfiguredArtifactDefinitions(cfg.ConcreteArtifacts()) } extractionDefinitions := artifacts.ExtractionDefinitionsFromConfig(cfg.Pipeline.Notarius) effective, err := artifacts.ResolveEffectiveArtifactSet(configured, nil) @@ -43,7 +43,7 @@ func writeArtifactList(out io.Writer, cfg *config.Config, catalog *artifacts.Art } writeArtifactLine(out, artifacts.ArtifactBoundsSession, lockSet) fmt.Fprintln(out, "Configured:") - origins := config.ArtifactFamilies(cfg.Pipeline).Members + origins := config.ArtifactFamilies(cfg.ArtifactCatalog).Members for _, entry := range catalog.ListConfigured() { state := "unavailable" if entry.Available { diff --git a/internal/app/restore_plan.go b/internal/app/restore_plan.go index f93fc54..7a1fad9 100644 --- a/internal/app/restore_plan.go +++ b/internal/app/restore_plan.go @@ -248,7 +248,7 @@ func buildPreviousCacheRestoreActions( if err != nil { return nil, err } - requirements := artifacts.CollectPreviousArtifactRequirements(cfg.Pipeline.Scriptorium.Artifacts, effective) + requirements := artifacts.CollectPreviousArtifactRequirements(cfg.ConcreteArtifacts(), effective) if len(requirements) == 0 { return nil, nil } diff --git a/internal/app/restore_plan_test.go b/internal/app/restore_plan_test.go index 32c98d9..477b511 100644 --- a/internal/app/restore_plan_test.go +++ b/internal/app/restore_plan_test.go @@ -481,6 +481,7 @@ func configureRestorePlanPreviousRequirement(cfg *config.Config, required bool) }, }, } + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: cfg.Pipeline.Scriptorium.Artifacts} } func restorePlanCurrentState(t *testing.T, cfg *config.Config) *RemoteCurrentState { diff --git a/internal/app/runner.go b/internal/app/runner.go index 2c28d37..90e11a7 100644 --- a/internal/app/runner.go +++ b/internal/app/runner.go @@ -467,7 +467,7 @@ func needsObjectStoreForRun(cfg *config.Config, stages []stage.Stage, effectiveS if !effective.Resolved() && cfg.Pipeline.Scriptorium != nil { var err error effective, err = artifacts.ResolveEffectiveArtifactSet( - artifacts.ConfiguredArtifactDefinitions(cfg.Pipeline.Scriptorium.Artifacts), + artifacts.ConfiguredArtifactDefinitions(cfg.ConcreteArtifacts()), nil, ) if err != nil { @@ -523,5 +523,5 @@ func configuredScriptoriumArtifacts(cfg *config.Config) map[string]config.Script if cfg == nil || cfg.Pipeline == nil || cfg.Pipeline.Scriptorium == nil { return nil } - return cfg.Pipeline.Scriptorium.Artifacts + return cfg.ConcreteArtifacts() } diff --git a/internal/app/runner_runtime.go b/internal/app/runner_runtime.go index 1095f25..915cfe0 100644 --- a/internal/app/runner_runtime.go +++ b/internal/app/runner_runtime.go @@ -46,7 +46,7 @@ func prepareInvocation(ctx context.Context, cfg *config.Config, plan BoundedPlan effectiveArtifacts := opts.EffectiveArtifacts if !effectiveArtifacts.Resolved() && cfg != nil && cfg.Pipeline != nil && cfg.Pipeline.Scriptorium != nil { var err error - effectiveArtifacts, err = resolveEffectiveArtifacts(cfg, nil) + effectiveArtifacts, err = resolveEffectiveArtifacts(cfg, opts.SelectedArtifacts) if err != nil { return nil, fmt.Errorf("resolve effective artifacts: %w", err) } @@ -59,6 +59,13 @@ func prepareInvocation(ctx context.Context, cfg *config.Config, plan BoundedPlan } } + if cfg != nil { + effectiveArtifacts = effectiveArtifacts.WithOrigins(effectiveArtifactOrigins(cfg.ArtifactCatalog)) + } + if len(opts.SelectedArtifacts) > 0 { + opts.SelectedArtifacts = effectiveArtifacts.Keys() + } + runID, err := dependencies.newRunID() if err != nil { return nil, fmt.Errorf("generate run id: %w", err) diff --git a/internal/app/runner_test.go b/internal/app/runner_test.go index 981699e..f965327 100644 --- a/internal/app/runner_test.go +++ b/internal/app/runner_test.go @@ -258,6 +258,11 @@ func (s selectedAnalyzeArtifactStage) Run(_ context.Context, env *stage.Env, m * func TestExecuteStagesPropagatesSelectedArtifactsToEnv(t *testing.T) { cfg := testConfig(t) + cfg.Pipeline.Scriptorium = &config.ScriptoriumConfig{} + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: map[string]config.ScriptoriumArtifactConfig{ + "player_handout": {PromptID: "handout", OutputPath: "artifacts/handout.md"}, + "session_recap": {PromptID: "recap", OutputPath: "artifacts/recap.md"}, + }} captured := []string{} stageToRun := captureSelectedArtifactsStage{name: "analyze", captured: &captured} @@ -494,7 +499,9 @@ func TestExecuteStagesPublishSkipsRequiredUnselectedConfiguredOutput(t *testing. }, }, } + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: cfg.Pipeline.Scriptorium.Artifacts} + cfg.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{PromptID: "handout", OutputPath: "artifacts/handout.md"} store := &manifest.LocalStore{} manifestPath := manifestPathFor(cfg) seed := manifest.New(cfg.Session.SessionID, time.Now().UTC()) diff --git a/internal/config/config.go b/internal/config/config.go index f1a5213..03f0f03 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -20,6 +20,15 @@ type Config struct { ArtifactCatalog *ArtifactCatalog } +// ConcreteArtifacts returns the invocation's derived artifact definitions. +// Callers consume the catalog without modifying it. +func (cfg *Config) ConcreteArtifacts() map[string]ScriptoriumArtifactConfig { + if cfg == nil || cfg.ArtifactCatalog == nil { + return nil + } + return cfg.ArtifactCatalog.Artifacts +} + // PipelineConfig contains durable pipeline-level settings. type PipelineConfig struct { Workspace WorkspaceConfig `yaml:"workspace" json:"workspace"` diff --git a/internal/stage/analyze.go b/internal/stage/analyze.go index f79934d..068e0a2 100644 --- a/internal/stage/analyze.go +++ b/internal/stage/analyze.go @@ -76,14 +76,14 @@ func (analyzeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S if scriptoriumCfg == nil { noWorkReason = "pipeline.scriptorium is not configured" scriptoriumCfg = &config.ScriptoriumConfig{} - } else if len(scriptoriumCfg.Artifacts) == 0 { + } else if len(env.Config.ConcreteArtifacts()) == 0 { noWorkReason = "no scriptorium artifacts configured" } effective := env.EffectiveArtifacts if !effective.Resolved() { effective, err = artifacts.ResolveEffectiveArtifactSet( - artifacts.ConfiguredArtifactDefinitions(scriptoriumCfg.Artifacts), + artifacts.ConfiguredArtifactDefinitions(env.Config.ConcreteArtifacts()), env.SelectedArtifactKeys, ) if err != nil { @@ -94,7 +94,7 @@ func (analyzeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S runtimeCatalog, err := buildAnalyzeRuntimeArtifactCatalog( paths, m, - scriptoriumCfg, + env.Config.ConcreteArtifacts(), env.Config.Pipeline.Notarius, effective, ) @@ -120,7 +120,7 @@ func (analyzeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S return nil, fmt.Errorf("analyze: reconcile configured artifacts: %w", err) } workPlan, err := planAnalyzeWork( - scriptoriumCfg, + env.Config.ConcreteArtifacts(), env.SelectedArtifactKeys, env.Force, reconciliation, @@ -138,7 +138,7 @@ func (analyzeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S } for _, item := range workPlan.ExecutionOrder { - artifactCfg := scriptoriumCfg.Artifacts[item.Key] + artifactCfg := env.Config.ConcreteArtifacts()[item.Key] fingerprint, _, _, err := computeAnalyzeArtifactFingerprint( item.Key, scriptoriumCfg, @@ -169,7 +169,7 @@ func analyzeArtifactOrigin(execution analyzeExecutionContext, key string) (confi if execution.Env == nil || execution.Env.Config == nil || execution.Env.Config.Pipeline == nil { return config.ArtifactFamilyMemberOrigin{}, false } - origin, ok := config.ArtifactFamilies(execution.Env.Config.Pipeline).Members[key] + origin, ok := config.ArtifactFamilies(execution.Env.Config.ArtifactCatalog).Members[key] return origin, ok } @@ -178,7 +178,7 @@ func artifactCfgMap(execution analyzeExecutionContext) map[string]config.Scripto execution.Env.Config.Pipeline.Scriptorium == nil { return nil } - return execution.Env.Config.Pipeline.Scriptorium.Artifacts + return execution.Env.Config.ConcreteArtifacts() } func staleAnalyzeDependents( @@ -384,14 +384,11 @@ func requiredBuiltInInputError(source string, execution analyzeExecutionContext) func buildAnalyzeRuntimeArtifactCatalog( paths artifacts.SessionPaths, m *manifest.Manifest, - scriptoriumCfg *config.ScriptoriumConfig, + definitions map[string]config.ScriptoriumArtifactConfig, notariusCfg *config.NotariusConfig, effective artifacts.EffectiveArtifactSet, ) (*artifacts.ArtifactCatalog, error) { - configured := artifacts.ConfiguredArtifactDefinitions(nil) - if scriptoriumCfg != nil { - configured = artifacts.ConfiguredArtifactDefinitions(scriptoriumCfg.Artifacts) - } + configured := artifacts.ConfiguredArtifactDefinitions(definitions) extractionDefinitions := artifacts.ExtractionDefinitionsFromConfig(notariusCfg) catalog, err := artifacts.BootstrapRuntimeCatalog(configured, effective, extractionDefinitions) if err != nil { diff --git a/internal/stage/analyze_checkpoint_test.go b/internal/stage/analyze_checkpoint_test.go index c6e4150..9d195f8 100644 --- a/internal/stage/analyze_checkpoint_test.go +++ b/internal/stage/analyze_checkpoint_test.go @@ -16,7 +16,7 @@ import ( func TestAnalyzeCheckpointsCompletedArtifactsBeforeInvokingNext(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts = independentAnalyzeArtifacts() + env.Config.ArtifactCatalog.Artifacts = independentAnalyzeArtifacts() manifestPath := artifacts.SessionManifestPathForCampaign( env.Config.Pipeline.Workspace.Root, m.Campaign, m.SessionID, ) @@ -34,7 +34,7 @@ func TestAnalyzeCheckpointsCompletedArtifactsBeforeInvokingNext(t *testing.T) { func TestAnalyzeCheckpointFailureStopsLaterWorkWithoutPromotingOutput(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts = independentAnalyzeArtifacts() + env.Config.ArtifactCatalog.Artifacts = independentAnalyzeArtifacts() cause := errors.New("injected checkpoint failure") baseStore := env.ManifestStore env.ManifestStore = &failingAnalyzeManifestStore{Store: baseStore, FailAt: 2, Err: cause} @@ -95,7 +95,7 @@ func TestAnalyzeReconciledCheckpointFailurePreventsFirstAdapterCall(t *testing.T func TestAnalyzeOutputsIncludeEveryCurrentRecordWithOriginalProducer(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts = independentAnalyzeArtifacts() + env.Config.ArtifactCatalog.Artifacts = independentAnalyzeArtifacts() if _, err := (analyzeStage{}).Run(context.Background(), env, m); err != nil { t.Fatalf("seed Run() error = %v", err) } diff --git a/internal/stage/analyze_failure_test.go b/internal/stage/analyze_failure_test.go index 65be168..2da0cf8 100644 --- a/internal/stage/analyze_failure_test.go +++ b/internal/stage/analyze_failure_test.go @@ -17,7 +17,7 @@ func TestAnalyzeAdapterFailureRecordsCompletedAndFailedArtifacts(t *testing.T) { for _, failAt := range []int{1, 2, 3} { t.Run(map[int]string{1: "first", 2: "middle", 3: "last"}[failAt], func(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts = independentAnalyzeArtifacts() + env.Config.ArtifactCatalog.Artifacts = independentAnalyzeArtifacts() cause := errors.New("injected adapter failure") runner := &indexedAnalyzeFailureRunner{FailAt: failAt, Err: cause} env.Scriptorium = runner @@ -72,7 +72,7 @@ func TestAnalyzeAdapterFailureRecordsCompletedAndFailedArtifacts(t *testing.T) { func TestAnalyzeCancellationPreservesEarlierCheckpoint(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts = independentAnalyzeArtifacts() + env.Config.ArtifactCatalog.Artifacts = independentAnalyzeArtifacts() env.Scriptorium = &indexedAnalyzeFailureRunner{FailAt: 2, Err: context.Canceled} _, err := (analyzeStage{}).Run(context.Background(), env, m) @@ -99,7 +99,7 @@ func TestAnalyzeCancellationPreservesEarlierCheckpoint(t *testing.T) { func TestAnalyzeMiddleFailureStalesDependentsAndPreservesUnrelatedCurrent(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts = chainedAnalyzeArtifacts() + env.Config.ArtifactCatalog.Artifacts = chainedAnalyzeArtifacts() _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { t.Fatal(err) diff --git a/internal/stage/analyze_family_origin_test.go b/internal/stage/analyze_family_origin_test.go index b4c3ea4..586b10a 100644 --- a/internal/stage/analyze_family_origin_test.go +++ b/internal/stage/analyze_family_origin_test.go @@ -23,7 +23,7 @@ func TestCurrentAnalyzeArtifactRecordPreservesResolvedFamilyOrigin(t *testing.T) t.Fatalf("LoadWithSessionOptions() error = %v", err) } const key = "character_meta_arannis" - artifactConfig, ok := cfg.Pipeline.Scriptorium.Artifacts[key] + artifactConfig, ok := cfg.ArtifactCatalog.Artifacts[key] if !ok { t.Fatalf("expanded artifact %q is unavailable", key) } diff --git a/internal/stage/analyze_fingerprint.go b/internal/stage/analyze_fingerprint.go index 7f60183..1c4fbc4 100644 --- a/internal/stage/analyze_fingerprint.go +++ b/internal/stage/analyze_fingerprint.go @@ -105,10 +105,10 @@ func computeAnalyzeFingerprints( if scriptoriumCfg == nil { return analyzeFingerprintSet{}, nil } - if err := config.ValidateScriptoriumArtifactDependencies(scriptoriumCfg.Artifacts); err != nil { + if err := config.ValidateScriptoriumArtifactDependencies(artifactCfgMap(execution)); err != nil { return analyzeFingerprintSet{}, err } - order, err := orderConfiguredAnalyzeArtifacts(scriptoriumCfg.Artifacts) + order, err := orderConfiguredAnalyzeArtifacts(artifactCfgMap(execution)) if err != nil { return analyzeFingerprintSet{}, err } @@ -127,7 +127,7 @@ func computeAnalyzeArtifactFingerprint( scriptoriumCfg *config.ScriptoriumConfig, execution analyzeExecutionContext, ) (string, resolvedAnalyzeInputs, []analyzeDependencyOutputIdentity, error) { - artifactCfg, ok := scriptoriumCfg.Artifacts[key] + artifactCfg, ok := artifactCfgMap(execution)[key] if !ok { return "", resolvedAnalyzeInputs{}, nil, fmt.Errorf("configured artifact %q is not defined", key) } diff --git a/internal/stage/analyze_fingerprint_test.go b/internal/stage/analyze_fingerprint_test.go index 844cf61..2982c2f 100644 --- a/internal/stage/analyze_fingerprint_test.go +++ b/internal/stage/analyze_fingerprint_test.go @@ -123,7 +123,7 @@ func TestComputeAnalyzeFingerprintsTracksEffectiveConfiguration(t *testing.T) { func TestComputeAnalyzeFingerprintsOrdersDependenciesAndRejectsInvalidGraphs(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) writeAnalyzeFile(t, filepath.Join(sessionPathsForEnv(env, m.SessionID).TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - env.Config.Pipeline.Scriptorium.Artifacts = map[string]config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts = map[string]config.ScriptoriumArtifactConfig{ "zeta": {DependsOn: []string{"middle"}}, "alpha": {}, "middle": {DependsOn: []string{"alpha"}}, @@ -151,8 +151,8 @@ func TestComputeAnalyzeFingerprintsOrdersDependenciesAndRejectsInvalidGraphs(t * } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - env.Config.Pipeline.Scriptorium.Artifacts = tt.configured - _, err := computeAnalyzeFingerprints(env.Config.Pipeline.Scriptorium, analyzeExecutionContext{}) + env.Config.ArtifactCatalog.Artifacts = tt.configured + _, err := computeAnalyzeFingerprints(env.Config.Pipeline.Scriptorium, analyzeExecutionContext{Env: env}) if err == nil { t.Fatal("computeAnalyzeFingerprints() error = nil, want invalid graph") } @@ -232,7 +232,7 @@ func computeFingerprintFixture(t *testing.T, options fingerprintFixtureOptions) env.Config.Pipeline.Scriptorium.ConfigPath = options.configPath env.Config.Pipeline.Scriptorium.Timeout = options.topTimeout env.Config.Pipeline.Scriptorium.RenderDebug = options.renderDebug - env.Config.Pipeline.Scriptorium.Artifacts["source_notes"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["source_notes"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/source_notes.md", } inputs := map[string]config.ScriptoriumInputConfig{} @@ -253,7 +253,7 @@ func computeFingerprintFixture(t *testing.T, options fingerprintFixtureOptions) if options.includePlayers { recordPreparedAnalyzeInput(t, m, "narratio.input.players", filepath.Join(paths.InputsDir, "players.yml"), "players:\n - Hrank\n") } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ Enabled: true, DependsOn: []string{"source_notes"}, PromptID: options.promptID, ProfileID: options.profileID, OutputPath: options.outputPath, Timeout: options.artifactTimeout, Inputs: inputs, Vars: vars, diff --git a/internal/stage/analyze_incremental_execution_test.go b/internal/stage/analyze_incremental_execution_test.go index 44bd76c..5d25b36 100644 --- a/internal/stage/analyze_incremental_execution_test.go +++ b/internal/stage/analyze_incremental_execution_test.go @@ -83,9 +83,9 @@ func TestAnalyzeExposesReusedPrerequisiteToScheduledDependent(t *testing.T) { if err != nil { t.Fatal(err) } - dependent := env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] + dependent := env.Config.ArtifactCatalog.Artifacts["player_handout"] dependent.PromptID = "dnd.player_handout.revised" - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = dependent + env.Config.ArtifactCatalog.Artifacts["player_handout"] = dependent env.SelectedArtifactKeys = []string{"player_handout"} fake.RunRequests = nil @@ -137,7 +137,7 @@ func TestAnalyzeRebuildsNestedStalePrerequisitesInDependencyOrder(t *testing.T) paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) addAnalyzeDependentArtifact(env) - env.Config.Pipeline.Scriptorium.Artifacts["quest_log"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["quest_log"] = config.ScriptoriumArtifactConfig{ Enabled: false, DependsOn: []string{"player_handout"}, PromptID: "dnd.quest_log", OutputPath: "artifacts/quest_log.md", Inputs: map[string]config.ScriptoriumInputConfig{ @@ -193,7 +193,7 @@ func TestAnalyzeLegacyExecutionPromotesOnlyEffectiveArtifacts(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) writeAnalyzeFile(t, filepath.Join(paths.ArtifactsDir, "player_handout.md"), "legacy handout\n") - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.player_handout", OutputPath: "artifacts/player_handout.md", } env.SelectedArtifactKeys = test.selected @@ -226,7 +226,7 @@ func TestAnalyzeLegacyExecutionPromotesOnlyEffectiveArtifacts(t *testing.T) { } func addAnalyzeDependentArtifact(env *Env) { - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, DependsOn: []string{"session_recap"}, PromptID: "dnd.player_handout", OutputPath: "artifacts/player_handout.md", Inputs: map[string]config.ScriptoriumInputConfig{ diff --git a/internal/stage/analyze_input_identity_test.go b/internal/stage/analyze_input_identity_test.go index aaa3f57..4828184 100644 --- a/internal/stage/analyze_input_identity_test.go +++ b/internal/stage/analyze_input_identity_test.go @@ -69,7 +69,7 @@ func TestResolveAnalyzeInputIdentitiesSupportsEverySourceKind(t *testing.T) { { name: "configured", sourceID: artifacts.ConfiguredArtifactSourceID("player_handout"), setup: func(t *testing.T, env *Env, m *manifest.Manifest) string { - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } path := filepath.Join(sessionPathsForEnv(env, m.SessionID).ArtifactsDir, "player_handout.md") @@ -243,7 +243,7 @@ func TestAnalyzeInputIdentityChangesWithContract(t *testing.T) { resolve := func(t *testing.T, schemaVersion string) analyzeInputIdentity { t.Helper() env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } path := filepath.Join(sessionPathsForEnv(env, m.SessionID).ArtifactsDir, "player_handout.md") @@ -282,7 +282,7 @@ func TestConfiguredAnalyzeInputRequiresCurrentManifestEvidence(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } path := filepath.Join(sessionPathsForEnv(env, m.SessionID).ArtifactsDir, "player_handout.md") @@ -338,14 +338,14 @@ func TestResolveAnalyzeInputIdentitiesOrdersConfiguredNamesDeterministically(t * func newAnalyzeIdentityExecution(t *testing.T, env *Env, m *manifest.Manifest) analyzeExecutionContext { t.Helper() - configured := artifacts.ConfiguredArtifactDefinitions(env.Config.Pipeline.Scriptorium.Artifacts) + configured := artifacts.ConfiguredArtifactDefinitions(env.Config.ArtifactCatalog.Artifacts) effective, err := artifacts.ResolveEffectiveArtifactSet(configured, nil) if err != nil { t.Fatal(err) } paths := sessionPathsForEnv(env, m.SessionID) catalog, err := buildAnalyzeRuntimeArtifactCatalog( - paths, m, env.Config.Pipeline.Scriptorium, env.Config.Pipeline.Notarius, effective, + paths, m, env.Config.ConcreteArtifacts(), env.Config.Pipeline.Notarius, effective, ) if err != nil { t.Fatal(err) diff --git a/internal/stage/analyze_plan.go b/internal/stage/analyze_plan.go index e0e0990..144c6d6 100644 --- a/internal/stage/analyze_plan.go +++ b/internal/stage/analyze_plan.go @@ -46,19 +46,16 @@ type analyzeWorkPlan struct { // planAnalyzeWork turns selection and reconciliation into one deterministic, // read-only work plan. It never invokes adapters or mutates manifest state. func planAnalyzeWork( - scriptoriumCfg *config.ScriptoriumConfig, + configured map[string]config.ScriptoriumArtifactConfig, selected []string, force bool, reconciliation analyzeReconciliation, ) (analyzeWorkPlan, error) { - if scriptoriumCfg == nil { - return analyzeWorkPlan{}, nil - } - if err := config.ValidateScriptoriumArtifactDependencies(scriptoriumCfg.Artifacts); err != nil { + if err := config.ValidateScriptoriumArtifactDependencies(configured); err != nil { return analyzeWorkPlan{}, err } effective, err := artifacts.ResolveEffectiveArtifactSet( - artifacts.ConfiguredArtifactDefinitions(scriptoriumCfg.Artifacts), + artifacts.ConfiguredArtifactDefinitions(configured), selected, ) if err != nil { @@ -66,11 +63,11 @@ func planAnalyzeWork( } targets := effective.Keys() targetSet := stringSet(targets) - closure, err := analyzeTargetDependencyClosure(scriptoriumCfg.Artifacts, targets) + closure, err := analyzeTargetDependencyClosure(configured, targets) if err != nil { return analyzeWorkPlan{}, err } - order, err := orderConfiguredAnalyzeArtifacts(scriptoriumCfg.Artifacts) + order, err := orderConfiguredAnalyzeArtifacts(configured) if err != nil { return analyzeWorkPlan{}, err } @@ -89,11 +86,11 @@ func planAnalyzeWork( plan := analyzeWorkPlan{ ExplicitTargets: append([]string(nil), targets...), Removed: removed, - StartingRecords: reconciledAnalyzeRecords(scriptoriumCfg.Artifacts, reconciliation), + StartingRecords: reconciledAnalyzeRecords(configured, reconciliation), } invalidated := make(map[string]struct{}) for _, state := range reconciliation.Ordered { - if _, configured := scriptoriumCfg.Artifacts[state.Key]; !configured || state.Stored == nil { + if _, present := configured[state.Key]; !present || state.Stored == nil { continue } if state.Stored.Status == manifest.AnalyzeArtifactCurrent && state.Reason != analyzeReconciliationCurrent { @@ -112,7 +109,7 @@ func planAnalyzeWork( if !ok { return analyzeWorkPlan{}, fmt.Errorf("analysis reconciliation is missing configured artifact %q", key) } - dependencies := normalizedAnalyzeDependencyKeys(scriptoriumCfg.Artifacts[key].DependsOn) + dependencies := normalizedAnalyzeDependencyKeys(configured[key].DependsOn) dependencyWork := false for _, dependency := range dependencies { dependencyWork = dependencyWork || scheduled[dependency] diff --git a/internal/stage/analyze_plan_test.go b/internal/stage/analyze_plan_test.go index 3025950..5a71a2d 100644 --- a/internal/stage/analyze_plan_test.go +++ b/internal/stage/analyze_plan_test.go @@ -21,7 +21,7 @@ func TestPlanAnalyzeWorkConsumesSemanticReconciliation(t *testing.T) { if err != nil { t.Fatal(err) } - plan, err := planAnalyzeWork(env.Config.Pipeline.Scriptorium, nil, false, reconciled) + plan, err := planAnalyzeWork(env.Config.ConcreteArtifacts(), nil, false, reconciled) if err != nil { t.Fatal(err) } @@ -34,7 +34,7 @@ func TestPlanAnalyzeWorkConsumesSemanticReconciliation(t *testing.T) { if err != nil { t.Fatal(err) } - plan, err = planAnalyzeWork(env.Config.Pipeline.Scriptorium, nil, false, reconciled) + plan, err = planAnalyzeWork(env.Config.ConcreteArtifacts(), nil, false, reconciled) if err != nil { t.Fatal(err) } @@ -149,7 +149,7 @@ func TestPlanAnalyzeWorkSelectionAndDependencyClosure(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { reconciliation := analyzePlanningReconciliation(tt.configured, tt.reasons, nil) - plan, err := planAnalyzeWork(&config.ScriptoriumConfig{Artifacts: tt.configured}, tt.selected, tt.force, reconciliation) + plan, err := planAnalyzeWork(tt.configured, tt.selected, tt.force, reconciliation) if err != nil { t.Fatal(err) } @@ -183,7 +183,7 @@ func TestPlanAnalyzeWorkSchedulesEveryNonCurrentReason(t *testing.T) { t.Run(string(reason), func(t *testing.T) { configured := map[string]config.ScriptoriumArtifactConfig{"target": {Enabled: true}} plan, err := planAnalyzeWork( - &config.ScriptoriumConfig{Artifacts: configured}, nil, false, + configured, nil, false, analyzePlanningReconciliation(configured, map[string]analyzeReconciliationReason{"target": reason}, nil), ) if err != nil { @@ -221,7 +221,7 @@ func TestPlanAnalyzeWorkRejectsUnknownSelectionAndInvalidGraphs(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - _, err := planAnalyzeWork(&config.ScriptoriumConfig{Artifacts: tt.configured}, tt.selected, false, analyzeReconciliation{}) + _, err := planAnalyzeWork(tt.configured, tt.selected, false, analyzeReconciliation{}) if err == nil || !strings.Contains(err.Error(), tt.want) { t.Fatalf("error = %v, want %q", err, tt.want) } @@ -250,7 +250,7 @@ func TestPlanAnalyzeWorkStartingRecordsPreserveOnlyValidConfiguredAuthority(t *t before := manifest.CloneAnalyzeArtifactCollection(map[string]manifest.AnalyzeArtifactRecord{ "unrelated": *stored["unrelated"], "invalid_unselected": *stored["invalid_unselected"], "removed": *removed, }) - plan, err := planAnalyzeWork(&config.ScriptoriumConfig{Artifacts: configured}, []string{"target"}, false, reconciliation) + plan, err := planAnalyzeWork(configured, []string{"target"}, false, reconciliation) if err != nil { t.Fatal(err) } @@ -285,7 +285,7 @@ func TestPlanAnalyzeWorkNonResumablePartialSelectionDoesNotPromoteUnselectedOutp reconciliation := analyzePlanningReconciliation(configured, map[string]analyzeReconciliationReason{ "target": analyzeReconciliationNonResumable, "legacy_unselected": analyzeReconciliationNonResumable, }, nil) - plan, err := planAnalyzeWork(&config.ScriptoriumConfig{Artifacts: configured}, []string{"target"}, false, reconciliation) + plan, err := planAnalyzeWork(configured, []string{"target"}, false, reconciliation) if err != nil { t.Fatal(err) } @@ -311,7 +311,7 @@ func TestPlanAnalyzeWorkOrderIsDeterministicAcrossMapInsertion(t *testing.T) { reasons := map[string]analyzeReconciliationReason{ "alpha": analyzeReconciliationMissing, "middle": analyzeReconciliationMissing, "zeta": analyzeReconciliationMissing, } - plan, err := planAnalyzeWork(&config.ScriptoriumConfig{Artifacts: configured}, nil, false, analyzePlanningReconciliation(configured, reasons, nil)) + plan, err := planAnalyzeWork(configured, nil, false, analyzePlanningReconciliation(configured, reasons, nil)) if err != nil { t.Fatal(err) } diff --git a/internal/stage/analyze_reconciliation.go b/internal/stage/analyze_reconciliation.go index ac4211b..d59c762 100644 --- a/internal/stage/analyze_reconciliation.go +++ b/internal/stage/analyze_reconciliation.go @@ -59,7 +59,7 @@ func reconcileAnalyzeArtifacts( stageRecord := analyzeManifestStageRecord(execution.Manifest) result := analyzeReconciliation{Ordered: make([]analyzeArtifactReconciliation, 0, len(fingerprints.Ordered))} for _, candidate := range fingerprints.Ordered { - artifactCfg := scriptoriumCfg.Artifacts[candidate.Key] + artifactCfg := artifactCfgMap(execution)[candidate.Key] result.Ordered = append(result.Ordered, reconcileAnalyzeArtifact( candidate, artifactCfg, @@ -71,7 +71,7 @@ func reconcileAnalyzeArtifacts( if stageRecord != nil && len(stageRecord.AnalyzeArtifacts) > 0 { removed := make([]string, 0) for key := range stageRecord.AnalyzeArtifacts { - if _, configured := scriptoriumCfg.Artifacts[key]; !configured { + if _, configured := artifactCfgMap(execution)[key]; !configured { removed = append(removed, key) } } diff --git a/internal/stage/analyze_reconciliation_test.go b/internal/stage/analyze_reconciliation_test.go index b0ad60b..6cb0b7e 100644 --- a/internal/stage/analyze_reconciliation_test.go +++ b/internal/stage/analyze_reconciliation_test.go @@ -106,7 +106,7 @@ func TestReconcileAnalyzeArtifactsClassifiesMissingAndRemovedConfiguration(t *te t.Run("removed config", func(t *testing.T) { env, m := currentAnalyzeReconciliationFixture(t) - delete(env.Config.Pipeline.Scriptorium.Artifacts, "session_recap") + delete(env.Config.ArtifactCatalog.Artifacts, "session_recap") reconciled, err := reconcileAnalyzeArtifacts(env.Config.Pipeline.Scriptorium, newAnalyzeIdentityExecution(t, env, m)) if err != nil { t.Fatal(err) @@ -178,9 +178,9 @@ func currentAnalyzeReconciliationFixture(t *testing.T) (*Env, *manifest.Manifest env, m, _ := setupAnalyzeEnv(t) paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["players"] = config.ScriptoriumInputConfig{Source: "narratio.input.players", Required: false} - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact fingerprints, err := computeAnalyzeFingerprints(env.Config.Pipeline.Scriptorium, newAnalyzeIdentityExecution(t, env, m)) if err != nil { @@ -204,15 +204,15 @@ func currentAnalyzeDependencyReconciliationFixture(t *testing.T) (*Env, *manifes writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) dependencyPath := filepath.Join(paths.ArtifactsDir, "source_notes.md") writeAnalyzeFile(t, dependencyPath, "notes\n") - env.Config.Pipeline.Scriptorium.Artifacts["source_notes"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["source_notes"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/source_notes.md", } - child := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + child := env.Config.ArtifactCatalog.Artifacts["session_recap"] child.DependsOn = []string{"source_notes"} child.Inputs["notes"] = config.ScriptoriumInputConfig{ Source: artifacts.ConfiguredArtifactSourceID("source_notes"), Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = child + env.Config.ArtifactCatalog.Artifacts["session_recap"] = child setCurrentAnalyzeEvidence(t, m, "source_notes", "artifacts/source_notes.md", dependencyPath) fingerprints, err := computeAnalyzeFingerprints(env.Config.Pipeline.Scriptorium, newAnalyzeIdentityExecution(t, env, m)) diff --git a/internal/stage/analyze_resume.go b/internal/stage/analyze_resume.go index 5d11ee0..7dcc6d3 100644 --- a/internal/stage/analyze_resume.go +++ b/internal/stage/analyze_resume.go @@ -32,7 +32,7 @@ func (analyzeStage) ValidateResume(_ context.Context, env *Env, m *manifest.Mani var err error if !effective.Resolved() { effective, err = artifacts.ResolveEffectiveArtifactSet( - artifacts.ConfiguredArtifactDefinitions(cfg.Artifacts), + artifacts.ConfiguredArtifactDefinitions(env.Config.ConcreteArtifacts()), env.SelectedArtifactKeys, ) if err != nil { @@ -41,7 +41,7 @@ func (analyzeStage) ValidateResume(_ context.Context, env *Env, m *manifest.Mani } paths := sessionPathsForEnv(env, sessionID) catalog, err := buildAnalyzeRuntimeArtifactCatalog( - paths, m, cfg, env.Config.Pipeline.Notarius, effective, + paths, m, env.Config.ConcreteArtifacts(), env.Config.Pipeline.Notarius, effective, ) if err != nil { return ResumeValidation{}, fmt.Errorf("analyze resume: build runtime artifact catalog: %w", err) @@ -54,11 +54,11 @@ func (analyzeStage) ValidateResume(_ context.Context, env *Env, m *manifest.Mani if err != nil { return ResumeValidation{}, fmt.Errorf("analyze resume: reconcile configured artifacts: %w", err) } - plan, err := planAnalyzeWork(cfg, env.SelectedArtifactKeys, env.Force, reconciliation) + plan, err := planAnalyzeWork(env.Config.ConcreteArtifacts(), env.SelectedArtifactKeys, env.Force, reconciliation) if err != nil { return ResumeValidation{}, fmt.Errorf("analyze resume: plan configured artifacts: %w", err) } - summary := analyzeResumeSummary(plan, env.Config.Pipeline) + summary := analyzeResumeSummary(plan, env.Config.ArtifactCatalog) if len(plan.ExecutionOrder) == 0 && len(plan.Removed) == 0 { return ResumeValidation{Resumable: true, Analyze: summary}, nil } @@ -76,16 +76,16 @@ func (analyzeStage) ValidateResume(_ context.Context, env *Env, m *manifest.Mani }, nil } -func analyzeResumeSummary(plan analyzeWorkPlan, pipeline *config.PipelineConfig) *AnalyzeResumeSummary { +func analyzeResumeSummary(plan analyzeWorkPlan, catalog *config.ArtifactCatalog) *AnalyzeResumeSummary { return &AnalyzeResumeSummary{ ExplicitTargets: append([]string(nil), plan.ExplicitTargets...), - PrerequisiteWork: exportAnalyzeResumeItems(plan.PrerequisiteWork, pipeline), - ExecutionOrder: exportAnalyzeResumeItems(plan.ExecutionOrder, pipeline), - ReusedCurrent: exportAnalyzeResumeItems(plan.ReusedCurrent, pipeline), + PrerequisiteWork: exportAnalyzeResumeItems(plan.PrerequisiteWork, catalog), + ExecutionOrder: exportAnalyzeResumeItems(plan.ExecutionOrder, catalog), + ReusedCurrent: exportAnalyzeResumeItems(plan.ReusedCurrent, catalog), } } -func exportAnalyzeResumeItems(items []analyzePlanItem, pipeline *config.PipelineConfig) []AnalyzeResumeArtifact { +func exportAnalyzeResumeItems(items []analyzePlanItem, catalog *config.ArtifactCatalog) []AnalyzeResumeArtifact { if len(items) == 0 { return nil } @@ -94,7 +94,7 @@ func exportAnalyzeResumeItems(items []analyzePlanItem, pipeline *config.Pipeline entry := AnalyzeResumeArtifact{ Key: item.Key, Role: string(item.Role), Reason: string(item.Reason), Forced: item.Forced, } - if origin, ok := config.ArtifactFamilies(pipeline).Members[item.Key]; ok { + if origin, ok := config.ArtifactFamilies(catalog).Members[item.Key]; ok { entry.Family, entry.CharacterID = origin.Family, origin.CharacterID } result = append(result, entry) diff --git a/internal/stage/analyze_resume_test.go b/internal/stage/analyze_resume_test.go index fa9ac79..75db093 100644 --- a/internal/stage/analyze_resume_test.go +++ b/internal/stage/analyze_resume_test.go @@ -43,27 +43,28 @@ func TestAnalyzeResumeValidationHonorsFullAndPartialSelections(t *testing.T) { func TestAnalyzeRemovedConfigurationRequiresAndPersistsReconciliation(t *testing.T) { for _, test := range []struct { name string - remove func(*config.PipelineConfig) + remove func(*config.Config) reason string }{ { name: "scriptorium omitted", - remove: func(pipeline *config.PipelineConfig) { - pipeline.Scriptorium = nil + remove: func(cfg *config.Config) { + cfg.Pipeline.Scriptorium = nil + cfg.ArtifactCatalog.Artifacts = nil }, reason: "pipeline.scriptorium is not configured", }, { name: "artifact map empty", - remove: func(pipeline *config.PipelineConfig) { - pipeline.Scriptorium.Artifacts = map[string]config.ScriptoriumArtifactConfig{} + remove: func(cfg *config.Config) { + cfg.ArtifactCatalog.Artifacts = map[string]config.ScriptoriumArtifactConfig{} }, reason: "no scriptorium artifacts configured", }, } { t.Run(test.name, func(t *testing.T) { env, m, initialRequests := currentAnalyzeFixture(t, false) - test.remove(env.Config.Pipeline) + test.remove(env.Config) validation, err := (analyzeStage{}).ValidateResume(context.Background(), env, m) if err != nil { @@ -119,9 +120,9 @@ func TestAnalyzeResumeValidationReportsForceAndCurrentPrerequisites(t *testing.T env.Force = false env.SelectedArtifactKeys = []string{"player_handout"} - dependent := env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] + dependent := env.Config.ArtifactCatalog.Artifacts["player_handout"] dependent.PromptID = "dnd.player_handout.revised" - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = dependent + env.Config.ArtifactCatalog.Artifacts["player_handout"] = dependent changed, err := (analyzeStage{}).ValidateResume(context.Background(), env, m) if err != nil { t.Fatal(err) @@ -210,7 +211,7 @@ func TestAnalyzeResumeSemanticChangesRemainArtifactGranular(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) addAnalyzeDependentArtifact(env) - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, DependsOn: []string{"session_recap"}, PromptID: "dnd.player_handout", ProfileID: "testing-model", OutputPath: "artifacts/player_handout.md", Inputs: map[string]config.ScriptoriumInputConfig{ @@ -218,14 +219,14 @@ func TestAnalyzeResumeSemanticChangesRemainArtifactGranular(t *testing.T) { }, Vars: map[string]any{"audience": "party"}, } - env.Config.Pipeline.Scriptorium.Artifacts["campaign_brief"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["campaign_brief"] = config.ScriptoriumArtifactConfig{ Enabled: true, DependsOn: []string{"player_handout"}, PromptID: "dnd.campaign_brief", OutputPath: "artifacts/campaign_brief.md", Inputs: map[string]config.ScriptoriumInputConfig{ "handout": {Source: "narratio.artifact.player_handout", Required: true}, }, } - env.Config.Pipeline.Scriptorium.Artifacts["unrelated"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["unrelated"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.unrelated", OutputPath: "artifacts/unrelated.md", Inputs: map[string]config.ScriptoriumInputConfig{ "transcript": {Source: "narratio.transcript.final_trimmed", Required: true}, diff --git a/internal/stage/analyze_test.go b/internal/stage/analyze_test.go index 96afa88..19f107b 100644 --- a/internal/stage/analyze_test.go +++ b/internal/stage/analyze_test.go @@ -84,13 +84,13 @@ func TestAnalyzeStickySessionVarOverridesConfiguredAndPreservesArbitraryVars(t * paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Vars = map[string]any{ "session_id": "configured-session", "character_name": "Hrank", "character_class": "Fighter", } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact if _, err := (analyzeStage{}).Run(context.Background(), env, m); err != nil { t.Fatalf("Run() error = %v", err) @@ -129,10 +129,10 @@ func TestAnalyzeRenderDebugArtifactOverrideFalseWinsOverGlobalTrue(t *testing.T) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) env.Config.Pipeline.Scriptorium.RenderDebug = true - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] disabled := false artifact.RenderDebug = &disabled - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact result, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -272,7 +272,7 @@ func TestAnalyzeOmitsOptionalCanonicalPreviousRecapWhenUnavailable(t *testing.T) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[]}`) setCurrentBuiltInEvidence(t, m, "polish", artifacts.TranscriptOutputKindPolished, artifacts.ArtifactTranscriptPolished, filepath.Join(paths.TranscriptsDir, "polished.json")) - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.session_recap", ProfileID: "local-quality", @@ -400,7 +400,7 @@ func TestAnalyzeIncludesCanonicalPreviousRecapWhenPreparedCacheExists(t *testing writeAnalyzeFile(t, previousRecapPath, "previous recap\n") setCurrentPreviousArtifactInput(t, m, previousRecapPath) - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.session_recap", ProfileID: "local-quality", @@ -436,7 +436,7 @@ func TestAnalyzeFailsWhenRequiredCanonicalPreviousRecapMissing(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[]}`) - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.session_recap", OutputPath: "artifacts/session_recap.md", @@ -468,13 +468,13 @@ func TestAnalyzeResolvesConfiguredArtifactInputFromDisabledArtifactOutput(t *tes playerHandoutPath := filepath.Join(paths.ArtifactsDir, "player_handout.md") writeAnalyzeFile(t, playerHandoutPath, "handout\n") - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["recap"] = config.ScriptoriumInputConfig{ Source: "narratio.artifact.player_handout", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } @@ -498,10 +498,10 @@ func TestAnalyzeDoesNotResolveIncidentalConfiguredArtifactFile(t *testing.T) { writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) writeAnalyzeFile(t, filepath.Join(paths.ArtifactsDir, "player_handout.md"), "handout\n") - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["recap"] = config.ScriptoriumInputConfig{Source: "narratio.artifact.player_handout", Required: true} - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } @@ -518,13 +518,13 @@ func TestAnalyzeMetadataIncludesGeneratedAndReusedArtifacts(t *testing.T) { playerHandoutPath := filepath.Join(paths.ArtifactsDir, "player_handout.md") writeAnalyzeFile(t, playerHandoutPath, "handout\n") - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["recap"] = config.ScriptoriumInputConfig{ Source: "narratio.artifact.player_handout", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } @@ -586,7 +586,7 @@ func TestAnalyzeRunsMultipleIndependentArtifactsInDeterministicOrder(t *testing. paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.player_handout", ProfileID: "local-quality", @@ -652,7 +652,12 @@ scriptorium: t.Fatalf("LoadPipeline() error = %v", err) } env.Config.Pipeline = loadedPipeline - if dependencies := loadedPipeline.Scriptorium.Artifacts["player_handout"].DependsOn; len(dependencies) != 1 || dependencies[0] != "session_recap" { + env.Config.ArtifactCatalog, err = config.DeriveArtifactCatalog(loadedPipeline, env.Config.Party) + if err != nil { + t.Fatal(err) + } + + if dependencies := env.Config.ConcreteArtifacts()["player_handout"].DependsOn; len(dependencies) != 1 || dependencies[0] != "session_recap" { t.Fatalf("materialized dependencies = %#v, want [session_recap]", dependencies) } @@ -679,7 +684,7 @@ func TestAnalyzeAppliesSelectedArtifactsFilter(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.player_handout", ProfileID: "local-quality", @@ -713,7 +718,7 @@ func TestAnalyzeMetadataIncludesMultipleGeneratedArtifacts(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.player_handout", ProfileID: "local-quality", @@ -748,13 +753,13 @@ func TestAnalyzeFailsWhenRequiredConfiguredArtifactMissing(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["recap"] = config.ScriptoriumInputConfig{ Source: "narratio.artifact.player_handout", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } @@ -773,13 +778,13 @@ func TestAnalyzeOmitsOptionalMissingConfiguredArtifactInput(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["recap"] = config.ScriptoriumInputConfig{ Source: "narratio.artifact.player_handout", Required: false, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: false, OutputPath: "artifacts/player_handout.md", } @@ -799,12 +804,12 @@ func TestAnalyzeOmitsOptionalMissingConfiguredArtifactInput(t *testing.T) { func TestAnalyzeRequiredPreviousSessionArtifactInputGuidesPrepareForce(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["previous_recap"] = config.ScriptoriumInputConfig{ Source: "narratio.previous_session.artifact.session_recap", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil { @@ -824,12 +829,12 @@ func TestAnalyzeResolvesCanonicalPreviousSessionArtifactFromManifestInput(t *tes writeAnalyzeFile(t, previousPath, "previous recap\n") setCurrentPreviousArtifactInput(t, m, previousPath) - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["previous_recap"] = config.ScriptoriumInputConfig{ Source: "narratio.previous_session.artifact.session_recap", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -848,12 +853,12 @@ func TestAnalyzeOmitsOptionalMissingCanonicalPreviousSessionArtifact(t *testing. paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["previous_recap"] = config.ScriptoriumInputConfig{ Source: "narratio.previous_session.artifact.session_recap", Required: false, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -877,12 +882,12 @@ func TestAnalyzeRenderDebugWithCanonicalPreviousSessionInput(t *testing.T) { writeAnalyzeFile(t, previousPath, "previous recap\n") setCurrentPreviousArtifactInput(t, m, previousPath) - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["previous_recap"] = config.ScriptoriumInputConfig{ Source: "narratio.previous_session.artifact.session_recap", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -908,12 +913,12 @@ func TestAnalyzeDoesNotCallObjectStoreForCanonicalPreviousSessionInput(t *testin writeAnalyzeFile(t, previousPath, "previous recap\n") setCurrentPreviousArtifactInput(t, m, previousPath) - sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + sessionRecap := env.Config.ArtifactCatalog.Artifacts["session_recap"] sessionRecap.Inputs["previous_recap"] = config.ScriptoriumInputConfig{ Source: "narratio.previous_session.artifact.session_recap", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = sessionRecap + env.Config.ArtifactCatalog.Artifacts["session_recap"] = sessionRecap tracker := &analyzeObjectStoreTracker{} env.ObjectStore = tracker @@ -932,9 +937,9 @@ func TestAnalyzeFailsWhenOutputPathMissing(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.OutputPath = "" - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil { @@ -972,11 +977,11 @@ func TestAnalyzeMissingOptionalBuiltInInputsAreOmitted(t *testing.T) { } { t.Run(source, func(t *testing.T) { env, m, fake := setupAnalyzeEnv(t) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs = map[string]config.ScriptoriumInputConfig{ "optional": {Source: source, Required: false}, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact if source == artifacts.ArtifactTranscriptFinalTrimmed { delete(m.Stages, "trim") } @@ -1011,11 +1016,11 @@ func TestAnalyzeMissingRequiredBuiltInInputsProvideExecutableGuidance(t *testing for _, tt := range tests { t.Run(tt.source, func(t *testing.T) { env, m, fake := setupAnalyzeEnv(t) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs = map[string]config.ScriptoriumInputConfig{ "required": {Source: tt.source, Required: true}, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact if tt.source == artifacts.ArtifactTranscriptFinalTrimmed { delete(m.Stages, "trim") } @@ -1041,12 +1046,12 @@ func TestAnalyzeSupportsProcessedTranscriptSourceWhenConfigured(t *testing.T) { writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[]}`) setCurrentBuiltInEvidence(t, m, "polish", artifacts.TranscriptOutputKindPolished, artifacts.ArtifactTranscriptPolished, filepath.Join(paths.TranscriptsDir, "polished.json")) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.polished", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1065,12 +1070,12 @@ func TestAnalyzeSupportsCanonicalTrimmedTranscriptSourceWhenConfigured(t *testin paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final_trimmed", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1091,12 +1096,12 @@ func TestAnalyzeSupportsNormalizedTranscriptSourceWhenConfigured(t *testing.T) { writeAnalyzeFile(t, normalizedPath, `{"segments":[{"id":1}]}`) setCurrentBuiltInEvidence(t, m, "normalize", artifacts.TranscriptOutputKindFinal, artifacts.ArtifactTranscriptFinal, normalizedPath) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1117,12 +1122,12 @@ func TestAnalyzeSupportsRenderedMarkdownTranscriptSourceWhenConfigured(t *testin writeAnalyzeFile(t, markdownPath, "# Session Transcript\n") setCurrentBuiltInEvidence(t, m, "render", artifacts.TranscriptOutputKindFinalMarkdown, artifacts.ArtifactTranscriptFinalMarkdown, markdownPath) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final_markdown", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1150,7 +1155,7 @@ func TestAnalyzeResolvesPreparedStableInputSources(t *testing.T) { recordPreparedAnalyzeInput(t, m, artifactpolicy.SourceInputGlossary, glossaryPath, "- term: Ten Towns\n") recordPreparedAnalyzeInput(t, m, artifactpolicy.SourceInputSpellCatalog, spellCatalogPath, "{\"spells\":[]}\n") - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["players"] = config.ScriptoriumInputConfig{ Source: "narratio.input.players", Required: true, @@ -1167,7 +1172,7 @@ func TestAnalyzeResolvesPreparedStableInputSources(t *testing.T) { Source: "narratio.input.spell_catalog", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1195,12 +1200,12 @@ func TestAnalyzeMissingRequiredPreparedStableInputFailsWithPrepareGuidance(t *te paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["players"] = config.ScriptoriumInputConfig{ Source: "narratio.input.players", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil { @@ -1217,12 +1222,12 @@ func TestAnalyzeMissingOptionalPreparedStableInputIsOmitted(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["players"] = config.ScriptoriumInputConfig{ Source: "narratio.input.players", Required: false, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1244,12 +1249,12 @@ func TestAnalyzeInvalidOptionalPreparedStableInputFailsWithPrepareGuidance(t *te recordPreparedAnalyzeInput(t, m, artifactpolicy.SourceInputPlayers, playersPath, "- Eric\n") m.Inputs[len(m.Inputs)-1].Checksum = strings.Repeat("0", 64) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["players"] = config.ScriptoriumInputConfig{ Source: "narratio.input.players", Required: false, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil || !strings.Contains(err.Error(), "prepared input source \"narratio.input.players\" is invalid") || @@ -1267,12 +1272,12 @@ func TestAnalyzeSupportsCanonicalNormalizedTranscriptSourceFromManifestOutput(t writeAnalyzeFile(t, manifestPath, `{"segments":[{"id":10}]}`) setCurrentBuiltInEvidence(t, m, "normalize", artifacts.TranscriptOutputKindFinal, artifacts.ArtifactTranscriptFinal, manifestPath) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1295,12 +1300,12 @@ func TestAnalyzeSupportsNormalizedTranscriptSourceFromManifestOutput(t *testing. writeAnalyzeFile(t, manifestPath, `{"segments":[{"id":10}]}`) setCurrentBuiltInEvidence(t, m, "normalize", artifacts.TranscriptOutputKindFinal, artifacts.ArtifactTranscriptFinal, manifestPath) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1316,12 +1321,12 @@ func TestAnalyzeSupportsNormalizedTranscriptSourceFromManifestOutput(t *testing. func TestAnalyzeFailsWhenNormalizedTranscriptMissing(t *testing.T) { env, m, fake := setupAnalyzeEnv(t) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil { @@ -1337,12 +1342,12 @@ func TestAnalyzeFailsWhenNormalizedTranscriptMissing(t *testing.T) { func TestAnalyzeFailsWhenRenderedMarkdownTranscriptMissing(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final_markdown", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil { @@ -1355,12 +1360,12 @@ func TestAnalyzeFailsWhenRenderedMarkdownTranscriptMissing(t *testing.T) { func TestAnalyzeFailsWhenRenderedTrimmedMarkdownTranscriptMissing(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{ Source: "narratio.transcript.final_trimmed_markdown", Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil { @@ -1506,7 +1511,7 @@ func TestAnalyzeSkipsWhenNoEnabledScriptoriumArtifactsConfigured(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{ Enabled: false, } @@ -1521,7 +1526,7 @@ func TestAnalyzeSkipsWhenNoEnabledScriptoriumArtifactsConfigured(t *testing.T) { func TestAnalyzeSkipsWhenArtifactMapEmpty(t *testing.T) { env, m, _ := setupAnalyzeEnv(t) - env.Config.Pipeline.Scriptorium.Artifacts = map[string]config.ScriptoriumArtifactConfig{} + env.Config.ArtifactCatalog.Artifacts = map[string]config.ScriptoriumArtifactConfig{} result, err := (analyzeStage{}).Run(context.Background(), env, m) if err != nil { @@ -1541,11 +1546,11 @@ func TestAnalyzePassesOnlyExplicitExtractionInputsToSelectedArtifact(t *testing. writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) extractionPaths := configureAnalyzeExtractionFixture(t, env, m) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["encounters"] = config.ScriptoriumInputConfig{ Source: artifacts.ExtractionArtifactSourceID("encounters"), Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact env.SelectedArtifactKeys = []string{"session_recap"} tracker := &analyzeObjectStoreTracker{} env.ObjectStore = tracker @@ -1576,11 +1581,11 @@ func TestAnalyzeRequiredUnavailableExtractionFailsWithGuidance(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) configureAnalyzeExtraction(t, env) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["encounters"] = config.ScriptoriumInputConfig{ Source: artifacts.ExtractionArtifactSourceID("encounters"), Required: true, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact _, err := (analyzeStage{}).Run(context.Background(), env, m) if err == nil || !strings.Contains(err.Error(), "pipeline.notarius output \"encounters\"") || !strings.Contains(err.Error(), "narratio run-stage extract 2026-05-03 --force") { @@ -1596,11 +1601,11 @@ func TestAnalyzeOmitsOptionalUnavailableExtraction(t *testing.T) { paths := sessionPathsForEnv(env, m.SessionID) writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`) configureAnalyzeExtraction(t, env) - artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := env.Config.ArtifactCatalog.Artifacts["session_recap"] artifact.Inputs["encounters"] = config.ScriptoriumInputConfig{ Source: artifacts.ExtractionArtifactSourceID("encounters"), Required: false, } - env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact + env.Config.ArtifactCatalog.Artifacts["session_recap"] = artifact if _, err := (analyzeStage{}).Run(context.Background(), env, m); err != nil { t.Fatalf("Run() error = %v", err) @@ -1737,6 +1742,8 @@ func setupAnalyzeEnv(t *testing.T) (*Env, *manifest.Manifest, *scriptorium.FakeR }, } + cfg.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: cfg.Pipeline.Scriptorium.Artifacts} + store := artifacts.NewLocalStore(workspace) if _, err := store.EnsureLayoutFor("icewind-dale", "2026-05-03"); err != nil { t.Fatalf("EnsureLayout() error = %v", err) diff --git a/internal/stage/prepare.go b/internal/stage/prepare.go index b240e2b..b6aef50 100644 --- a/internal/stage/prepare.go +++ b/internal/stage/prepare.go @@ -551,14 +551,14 @@ func collectPreparePreviousRequirements(cfg *config.Config, effective artifacts. if !effective.Resolved() { var err error effective, err = artifacts.ResolveEffectiveArtifactSet( - artifacts.ConfiguredArtifactDefinitions(cfg.Pipeline.Scriptorium.Artifacts), + artifacts.ConfiguredArtifactDefinitions(cfg.ConcreteArtifacts()), nil, ) if err != nil { return nil, err } } - return artifacts.CollectPreviousArtifactRequirements(cfg.Pipeline.Scriptorium.Artifacts, effective), nil + return artifacts.CollectPreviousArtifactRequirements(cfg.ConcreteArtifacts(), effective), nil } func clearManagedPreviousState(paths artifacts.SessionPaths) error { diff --git a/internal/stage/prepare_effective_artifacts_test.go b/internal/stage/prepare_effective_artifacts_test.go index 25fdf3c..3fc278e 100644 --- a/internal/stage/prepare_effective_artifacts_test.go +++ b/internal/stage/prepare_effective_artifacts_test.go @@ -21,7 +21,8 @@ func TestCollectPreparePreviousRequirementsUsesExplicitDisabledArtifact(t *testi t.Fatalf("ResolveEffectiveArtifactSet() error = %v", err) } requirements, err := collectPreparePreviousRequirements(&config.Config{ - Pipeline: &config.PipelineConfig{Scriptorium: &config.ScriptoriumConfig{Artifacts: configured}}, + Pipeline: &config.PipelineConfig{Scriptorium: &config.ScriptoriumConfig{}}, + ArtifactCatalog: &config.ArtifactCatalog{Artifacts: configured}, }, effective) if err != nil { t.Fatalf("collectPreparePreviousRequirements() error = %v", err) diff --git a/internal/stage/prepare_previous_test.go b/internal/stage/prepare_previous_test.go index 94c3342..714e64f 100644 --- a/internal/stage/prepare_previous_test.go +++ b/internal/stage/prepare_previous_test.go @@ -354,6 +354,7 @@ func previousHydrationFixture(t *testing.T) (*Env, artifacts.SessionPaths, *stor }, }, } + env.Config.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: env.Config.Pipeline.Scriptorium.Artifacts} fake := &storage.FakeBackend{} env.ObjectStore = fake diff --git a/internal/stage/prepare_test.go b/internal/stage/prepare_test.go index a434549..13724ce 100644 --- a/internal/stage/prepare_test.go +++ b/internal/stage/prepare_test.go @@ -850,6 +850,7 @@ func configurePreparePreviousArtifactSource(env *Env, required bool) { }, }, } + env.Config.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: env.Config.Pipeline.Scriptorium.Artifacts} } func setupPrepareEnv(t *testing.T) (*Env, *manifest.Manifest) { diff --git a/internal/stage/publish.go b/internal/stage/publish.go index 8080d9d..cb21e34 100644 --- a/internal/stage/publish.go +++ b/internal/stage/publish.go @@ -125,7 +125,7 @@ func (publishStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S runtimeCatalog, err := buildPublishRuntimeArtifactCatalog( sessionPaths, m, - env.Config.Pipeline.Scriptorium, + env.Config.ConcreteArtifacts(), env.Config.Pipeline.Notarius, ) if err != nil { diff --git a/internal/stage/publish_outputs.go b/internal/stage/publish_outputs.go index 60a0102..14fda88 100644 --- a/internal/stage/publish_outputs.go +++ b/internal/stage/publish_outputs.go @@ -173,14 +173,11 @@ func extractionOutputSetFromCatalog(catalog *artifacts.ArtifactCatalog) map[stri func buildPublishRuntimeArtifactCatalog( paths artifacts.SessionPaths, m *manifest.Manifest, - scriptoriumCfg *config.ScriptoriumConfig, + definitions map[string]config.ScriptoriumArtifactConfig, notariusCfg *config.NotariusConfig, ) (*artifacts.ArtifactCatalog, error) { extractionDefinitions := artifacts.ExtractionDefinitionsFromConfig(notariusCfg) - configured := artifacts.ConfiguredArtifactDefinitions(nil) - if scriptoriumCfg != nil { - configured = artifacts.ConfiguredArtifactDefinitions(scriptoriumCfg.Artifacts) - } + configured := artifacts.ConfiguredArtifactDefinitions(definitions) effective, err := artifacts.ResolveEffectiveArtifactSet(configured, nil) if err != nil { return nil, err diff --git a/internal/stage/publish_test.go b/internal/stage/publish_test.go index 597617c..50b8ccd 100644 --- a/internal/stage/publish_test.go +++ b/internal/stage/publish_test.go @@ -602,7 +602,7 @@ func TestPublishSkipsOptionalMissingOutput(t *testing.T) { func TestPublishSkipsRequiredUnselectedConfiguredOutput(t *testing.T) { env, m, _ := publishFixture(t) env.SelectedArtifactKeys = []string{"player_handout"} - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.player_handout", OutputPath: "artifacts/player_handout.md", @@ -663,7 +663,7 @@ func TestPublishOmitsStaleConfiguredArtifactAndPublishesUnrelatedCurrentArtifact paths := publishSessionPaths(env, m) handoutPath := filepath.Join(paths.ArtifactsDir, "player_handout.md") writeStageTestFile(t, handoutPath, "# handout\n") - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, OutputPath: "artifacts/player_handout.md", } setCurrentAnalyzeEvidence(t, m, "player_handout", "artifacts/player_handout.md", handoutPath) @@ -716,7 +716,7 @@ func TestPublishLockedSelectedOutputIsUnpublishedWithoutPriorDeclaration(t *test func TestPublishLockedUnselectedConfiguredOutputSkipsAsUnselected(t *testing.T) { env, m, _ := publishFixture(t) env.SelectedArtifactKeys = []string{"player_handout"} - env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.player_handout", OutputPath: "artifacts/player_handout.md", @@ -1101,7 +1101,7 @@ func TestPublishKeepsSameBasenameSourcesDistinct(t *testing.T) { env, m, _ := publishFixture(t) otherPath := filepath.Join(env.Config.Pipeline.Workspace.Root, "work", m.Campaign, m.SessionID, "reports", "session_recap.md") writeStageTestFile(t, otherPath, "# other recap\n") - env.Config.Pipeline.Scriptorium.Artifacts["other_recap"] = config.ScriptoriumArtifactConfig{ + env.Config.ArtifactCatalog.Artifacts["other_recap"] = config.ScriptoriumArtifactConfig{ Enabled: true, PromptID: "dnd.other_recap", OutputPath: "reports/session_recap.md", } setCurrentAnalyzeEvidence(t, m, "other_recap", "reports/session_recap.md", otherPath) @@ -1233,6 +1233,7 @@ func publishFixture(t *testing.T) (*Env, *manifest.Manifest, string) { }, ObjectStore: &storage.FakeBackend{}, } + env.Config.ArtifactCatalog = &config.ArtifactCatalog{Artifacts: env.Config.Pipeline.Scriptorium.Artifacts} return env, m, runRoot }