Use derived artifact catalogs throughout planning and execution

This commit is contained in:
2026-11-20 04:42:23 +00:00
parent 6900cad104
commit 065a615e5f
36 changed files with 377 additions and 205 deletions

View File

@@ -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}

View File

@@ -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

View File

@@ -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)

View File

@@ -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")
}
}

View File

@@ -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
}

View File

@@ -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")
}
}

View File

@@ -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 {

View File

@@ -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
}

View File

@@ -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 {

View File

@@ -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()
}

View File

@@ -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)

View File

@@ -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())