From 3b1b4c9bcf4780038ce6a1e5b27fa3824f3710ed Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Sun, 22 Nov 2026 02:24:45 +0000 Subject: [PATCH] Unify chunk-plan caching and remove checkpoint execution paths --- docs/roadmap/implementation.md | 23 + internal/cli/cache_contract_test.go | 323 ------- .../cli/recompute_execution_contract_test.go | 338 ------- internal/cli/recompute_policy_test.go | 56 -- internal/cli/run.go | 396 +------- internal/framework/pipeline/checkpoint.go | 504 ---------- internal/framework/pipeline/chunk_cache.go | 29 - .../framework/pipeline/chunk_cache_test.go | 20 - .../pipeline/chunk_plan_cache_test.go | 425 +++++++++ .../framework/pipeline/chunk_plan_store.go | 49 - internal/framework/pipeline/diagnostics.go | 30 - .../framework/pipeline/evidence_output.go | 2 +- internal/framework/pipeline/handoff.go | 60 -- internal/framework/pipeline/prepare.go | 21 +- .../pipeline/prepared_fingerprints.go | 88 -- internal/framework/pipeline/runner.go | 207 ++--- .../runner_accepted_checkpoint_test.go | 396 -------- internal/framework/pipeline/runner_cache.go | 52 +- .../framework/pipeline/runner_chunk_plan.go | 217 +---- .../pipeline/runner_chunk_plan_test.go | 876 ++---------------- .../framework/pipeline/runner_concurrent.go | 224 +---- internal/framework/pipeline/runner_typed.go | 247 +---- .../pipeline/runner_typed_checkpoint_test.go | 165 ---- .../pipeline/synchronized_collaborators.go | 221 +---- .../framework/pipeline/typed_execution.go | 1 + .../pipeline/typed_resolution_test.go | 5 +- 26 files changed, 717 insertions(+), 4258 deletions(-) delete mode 100644 internal/cli/recompute_execution_contract_test.go delete mode 100644 internal/cli/recompute_policy_test.go delete mode 100644 internal/framework/pipeline/checkpoint.go delete mode 100644 internal/framework/pipeline/chunk_cache.go delete mode 100644 internal/framework/pipeline/chunk_cache_test.go create mode 100644 internal/framework/pipeline/chunk_plan_cache_test.go delete mode 100644 internal/framework/pipeline/chunk_plan_store.go delete mode 100644 internal/framework/pipeline/prepared_fingerprints.go delete mode 100644 internal/framework/pipeline/runner_accepted_checkpoint_test.go delete mode 100644 internal/framework/pipeline/runner_typed_checkpoint_test.go diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index 1673d9aa..cb826b51 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -1288,6 +1288,29 @@ native prepared details retained on a hit without an execution event. ## Stage 28: Unify Chunk-Plan Reuse And Remove Checkpoint Execution Paths +**Status:** Complete. Native chunk producers now use the same accepted-result +cache as typed artifacts, storing only the final domain plan under the initial +native message-content hash after materialization and complete assessment. +Hits decode and rematerialize against the current source without semantic +reassessment; unusable entries miss without entering conversation history. +Deterministic chunkers remain uncached. Removed source-digest plan lookup, +checkpoint collaborators/transitions, dependency fingerprint collection, +required-lane hydration, resume barriers, and recomputation policy from runner, +preparation, handoffs, and CLI cache composition. The CLI cache collaborator now +uses the resolved unified root; full native run wiring remains Stage 33. +Replaced canonical-partition/checkpoint tests with native-provider/filesystem +coverage for final correction, content/reference changes, settings-only reuse, +current-source rematerialization, unusable ranges/data, cache modes, terminal +exclusions, failed refresh, and unchanged legacy files. Retained current chunk-map +handoff/schema and deterministic provenance checks. Focused pipeline tests/vet/ +repeated race checks, cache/contracts/source/chunk-map/generic/Seriatim/ +reconciliation tests, production pipeline/cache/config builds, and +`git diff --check` pass. Full pipeline tests still stop at retired fixtures +(including checkpoint helpers and NormalizeRetry); CLI setup still stops at old +ConfigKit's removed YAML plugin/limit import. Those suites are not claimed +passing. Stage 35 owns remaining obsolete stores, module fingerprint declarations, +and fixture cleanup; final assembled verification remains required. + **Goal:** LLM chunk plans use the same accepted-result cache and no second store. **Inspect/change:** `runner_chunk_plan.go`, `chunk_cache.go`, `chunk_plan_store.go`, diff --git a/internal/cli/cache_contract_test.go b/internal/cli/cache_contract_test.go index f235e6fd..908d0383 100644 --- a/internal/cli/cache_contract_test.go +++ b/internal/cli/cache_contract_test.go @@ -3,331 +3,11 @@ package cli import ( "bytes" "errors" - "fmt" "os" - "path/filepath" "strings" "testing" - - "gitea.maximumdirect.net/eric/notarius/internal/framework/chunkplan" - "gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline" ) -func TestRunChunkPlanModePrecedenceAndValidation(t *testing.T) { - tests := []struct { - name string - fileMode string - envMode string - cliMode string - wantStores int - }{ - {name: "default", wantStores: 1}, - {name: "file", fileMode: "bypass"}, - {name: "retired environment has no effect", envMode: "bypass", wantStores: 1}, - {name: "cli", envMode: "refresh", cliMode: "bypass"}, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - roots := newStateTestRoots(t) - if tt.name == "default" { - removeStateTestConfigLine(t, roots.config, " mode: auto\n") - } else if tt.fileMode != "" { - replaceStateTestConfigLine(t, roots.config, " mode: auto\n", " mode: "+tt.fileMode+"\n") - } - - var stores []string - opts := newStateTestHarness().options() - opts.LookupEnv = func(name string) (string, bool) { - if name == "NOTARIUS_CACHE_CHUNK_PLANS_MODE" && tt.envMode != "" { - return tt.envMode, true - } - return "", false - } - opts.ChunkPlanStoreFactory = func(root string) (pipeline.ChunkPlanStore, error) { - stores = append(stores, root) - return chunkplan.NewFilesystemStore(root) - } - - args := []string{"run", "sample", "--config", roots.config, "--input", roots.input} - if tt.cliMode != "" { - args = append(args, "--chunk_cache", tt.cliMode) - } - var stdout, stderr bytes.Buffer - if code := RunWithOptions(args, &stdout, &stderr, opts); code != 0 { - t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String()) - } - assertStateTestOutput(t, roots.output) - if len(stores) != tt.wantStores { - t.Fatalf("chunk plan store roots = %v, want %d stores", stores, tt.wantStores) - } - if tt.wantStores == 1 && stores[0] != roots.plans { - t.Fatalf("chunk plan store root = %q, want %q", stores[0], roots.plans) - } - if tt.wantStores == 0 { - assertAbsent(t, roots.plans) - } - }) - } - - t.Run("invalid cli syntax is a usage error", func(t *testing.T) { - roots := newStateTestRoots(t) - var stdout, stderr bytes.Buffer - code := RunWithOptions([]string{"run", "sample", "--config", roots.config, "--input", roots.input, "--chunk_cache", "invalid"}, &stdout, &stderr, newStateTestHarness().options()) - if code != 2 || stdout.Len() != 0 || stderr.Len() == 0 { - t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String()) - } - assertNoRunState(t, roots) - }) - - for _, tt := range []struct { - name string - }{ - {name: "invalid file mode"}, - } { - t.Run(tt.name, func(t *testing.T) { - roots := newStateTestRoots(t) - opts := newStateTestHarness().options() - replaceStateTestConfigLine(t, roots.config, " mode: auto\n", " mode: invalid\n") - var stdout, stderr bytes.Buffer - code := RunWithOptions([]string{"run", "sample", "--config", roots.config, "--input", roots.input}, &stdout, &stderr, opts) - if code != 1 || stdout.Len() != 0 || stderr.Len() == 0 { - t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String()) - } - assertNoRunState(t, roots) - }) - } -} - -func TestRunChunkPlanRootSelectionAndFailures(t *testing.T) { - t.Run("empty configured root uses the per-user cache root", func(t *testing.T) { - roots := newStateTestRoots(t) - removeStateTestConfigLine(t, roots.config, fmt.Sprintf(" directory: %q\n", roots.plans)) - userCache := filepath.Join(t.TempDir(), "user-cache") - var stores []string - opts := newStateTestHarness().options() - opts.UserCacheDir = func() (string, error) { return userCache, nil } - opts.ChunkPlanStoreFactory = func(root string) (pipeline.ChunkPlanStore, error) { - stores = append(stores, root) - return chunkplan.NewFilesystemStore(root) - } - var stdout, stderr bytes.Buffer - code := RunWithOptions([]string{"run", "sample", "--config", roots.config, "--input", roots.input}, &stdout, &stderr, opts) - if code != 0 { - t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String()) - } - wantRoot := filepath.Join(userCache, "notarius", "chunk-plans") - if len(stores) != 1 || stores[0] != wantRoot { - t.Fatalf("chunk plan store roots = %v, want [%q]", stores, wantRoot) - } - assertFile(t, filepath.Join(wantRoot, strings.TrimPrefix(stateTestDigest, "sha256:"), "plan.json")) - assertAbsent(t, roots.plans) - }) - - t.Run("bypass avoids default cache dependencies", func(t *testing.T) { - roots := newStateTestRoots(t) - removeStateTestConfigLine(t, roots.config, fmt.Sprintf(" directory: %q\n", roots.plans)) - userCacheCalls := 0 - storeCalls := 0 - opts := newStateTestHarness().options() - opts.UserCacheDir = func() (string, error) { - userCacheCalls++ - return "", errors.New("user cache must not be resolved") - } - opts.ChunkPlanStoreFactory = func(string) (pipeline.ChunkPlanStore, error) { - storeCalls++ - return nil, errors.New("chunk plan store must not be constructed") - } - var stdout, stderr bytes.Buffer - code := RunWithOptions([]string{"run", "sample", "--config", roots.config, "--input", roots.input, "--chunk_cache", "bypass"}, &stdout, &stderr, opts) - if code != 0 { - t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String()) - } - if userCacheCalls != 0 || storeCalls != 0 { - t.Fatalf("user cache calls=%d store calls=%d, want none", userCacheCalls, storeCalls) - } - assertStateTestOutput(t, roots.output) - assertAbsent(t, roots.plans) - }) - - t.Run("user cache resolution failure has context and no output", func(t *testing.T) { - roots := newStateTestRoots(t) - removeStateTestConfigLine(t, roots.config, fmt.Sprintf(" directory: %q\n", roots.plans)) - opts := newStateTestHarness().options() - opts.UserCacheDir = func() (string, error) { return "", errors.New("cache home unavailable") } - var stdout, stderr bytes.Buffer - code := RunWithOptions([]string{"run", "sample", "--config", roots.config, "--input", roots.input}, &stdout, &stderr, opts) - if code != 1 || !strings.Contains(stderr.String(), "resolve chunk plan root") || !strings.Contains(stderr.String(), "cache home unavailable") { - t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String()) - } - assertNoRunState(t, roots) - }) - - t.Run("store construction failure has context and no output", func(t *testing.T) { - roots := newStateTestRoots(t) - opts := newStateTestHarness().options() - opts.ChunkPlanStoreFactory = func(root string) (pipeline.ChunkPlanStore, error) { - return nil, fmt.Errorf("store unavailable") - } - var stdout, stderr bytes.Buffer - code := RunWithOptions([]string{"run", "sample", "--config", roots.config, "--input", roots.input}, &stdout, &stderr, opts) - want := fmt.Sprintf("create chunk plan store at %q", roots.plans) - if code != 1 || !strings.Contains(stderr.String(), want) || !strings.Contains(stderr.String(), "store unavailable") { - t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String()) - } - assertNoRunState(t, roots) - }) - - t.Run("checkpoint root resolution failure has context and no output", func(t *testing.T) { - roots := newStateTestRoots(t) - removeStateTestConfigLine(t, roots.config, fmt.Sprintf(" directory: %q\n", roots.checkpoints)) - opts := newStateTestHarness().options() - opts.UserCacheDir = func() (string, error) { return "", errors.New("checkpoint cache unavailable") } - result := runStateTest(t, roots, opts, false, true, "bypass") - if result.code != 1 || !strings.Contains(result.stderr, "resolve checkpoint root") || !strings.Contains(result.stderr, "checkpoint cache unavailable") { - t.Fatalf("code=%d stdout=%q stderr=%q", result.code, result.stdout, result.stderr) - } - assertNoRunState(t, roots) - }) -} - -func TestRunAutoReusesPlanWhenRunInputsChange(t *testing.T) { - roots := newStateTestRoots(t) - data, err := os.ReadFile(roots.config) - if err != nil { - t.Fatal(err) - } - configText := replaceRequiredOnce(t, string(data), " chunk:\n module: test/chunk\n", ` chunk: - module: test/chunk - options: - strategy: first -`) - configText = replaceRequiredOnce(t, configText, " output:\n module: test/output\n", ` other: - extract: - module: test/extract - merge: - module: test/merge - normalize: - module: test/normalize - output: - module: test/output -`) - if err := os.WriteFile(roots.config, []byte(configText), 0o600); err != nil { - t.Fatal(err) - } - referencePath := filepath.Join(filepath.Dir(roots.input), "reference.txt") - if err := os.WriteFile(referencePath, []byte("reference content"), 0o600); err != nil { - t.Fatal(err) - } - harness := newStateTestHarness() - var firstStdout, firstStderr bytes.Buffer - first := RunWithOptions([]string{"run", "sample", "--config", roots.config, "--input", roots.input}, &firstStdout, &firstStderr, harness.options()) - if first != 0 { - t.Fatalf("first run code=%d stdout=%q stderr=%q", first, firstStdout.String(), firstStderr.String()) - } - configData, err := os.ReadFile(roots.config) - if err != nil { - t.Fatal(err) - } - configText = replaceRequiredOnce(t, string(configData), "strategy: first", "strategy: second") - if err := os.WriteFile(roots.config, []byte(configText), 0o600); err != nil { - t.Fatal(err) - } - var stdout, stderr bytes.Buffer - second := RunWithOptions([]string{ - "run", "sample", "--config", roots.config, "--input", roots.input, - "--only", "items", "--reference", "chunk.cache-reference=" + referencePath, - }, &stdout, &stderr, harness.options()) - if second != 0 { - t.Fatalf("second run code=%d stdout=%q stderr=%q", second, stdout.String(), stderr.String()) - } - harness.mu.Lock() - chunkCalls := harness.chunkCalls - sessions := append([]string(nil), harness.sessionIDs...) - harness.mu.Unlock() - if chunkCalls != 1 { - t.Fatalf("chunk calls across changed run inputs = %d, want 1", chunkCalls) - } - rawInput, err := os.ReadFile(roots.input) - if err != nil { - t.Fatal(err) - } - wantSessionID, err := resolvePromptSessionID("", "test/input", rawInput) - if err != nil { - t.Fatal(err) - } - for _, sessionID := range sessions { - if sessionID != wantSessionID { - t.Fatalf("session IDs across reference changes = %#v, want %q", sessions, wantSessionID) - } - } - assertFile(t, filepath.Join(roots.plans, strings.TrimPrefix(stateTestDigest, "sha256:"), "plan.json")) - assertAnyFile(t, roots.output) -} - -func TestRunResumeSelectsConfiguredOrPerUserCheckpointRoot(t *testing.T) { - for _, configured := range []bool{true, false} { - name := "per-user root" - if configured { - name = "configured root" - } - t.Run(name, func(t *testing.T) { - roots := newStateTestRoots(t) - if !configured { - removeStateTestConfigLine(t, roots.config, fmt.Sprintf(" directory: %q\n", roots.checkpoints)) - } - userCache := filepath.Join(t.TempDir(), "user-cache") - userCacheCalls := 0 - opts := newStateTestHarness().options() - opts.UserCacheDir = func() (string, error) { - userCacheCalls++ - return userCache, nil - } - result := runStateTest(t, roots, opts, false, true, "bypass") - if result.code != 0 { - t.Fatalf("code=%d stdout=%q stderr=%q", result.code, result.stdout, result.stderr) - } - wantRoot := roots.checkpoints - wantCalls := 0 - if !configured { - wantRoot = filepath.Join(userCache, "notarius", "checkpoints") - wantCalls = 1 - } - if userCacheCalls != wantCalls { - t.Fatalf("user cache calls = %d, want %d", userCacheCalls, wantCalls) - } - assertAnyFile(t, wantRoot) - if !configured { - assertAbsent(t, roots.checkpoints) - } - assertStateTestOutput(t, roots.output) - }) - } - - t.Run("disabled avoids checkpoint root resolution", func(t *testing.T) { - roots := newStateTestRoots(t) - replaceStateTestConfigLine(t, roots.config, " enabled: true\n", " enabled: false\n") - removeStateTestConfigLine(t, roots.config, fmt.Sprintf(" directory: %q\n", roots.checkpoints)) - opts := newStateTestHarness().options() - opts.UserCacheDir = func() (string, error) { return "", errors.New("checkpoint cache must not be resolved") } - result := runStateTest(t, roots, opts, false, false, "bypass") - if result.code != 0 { - t.Fatalf("code=%d stdout=%q stderr=%q", result.code, result.stdout, result.stderr) - } - assertStateTestOutput(t, roots.output) - assertAbsent(t, roots.checkpoints) - }) - - t.Run("resume requires enabled checkpoint recording", func(t *testing.T) { - roots := newStateTestRoots(t) - replaceStateTestConfigLine(t, roots.config, " enabled: true\n", " enabled: false\n") - result := runStateTest(t, roots, newStateTestHarness().options(), true, true, "bypass") - if result.code != 1 || !strings.Contains(result.stderr, "--resume requires cache.checkpoints.enabled: true") { - t.Fatalf("code=%d stdout=%q stderr=%q", result.code, result.stdout, result.stderr) - } - assertNoRunState(t, roots) - }) -} - func TestConfigCommandsDoNotResolveRunState(t *testing.T) { for _, args := range [][]string{ {"config", "validate", "--config"}, @@ -338,9 +18,6 @@ func TestConfigCommandsDoNotResolveRunState(t *testing.T) { roots := newStateTestRoots(t) opts := newStateTestHarness().options() opts.UserCacheDir = func() (string, error) { return "", errors.New("state root must not be resolved") } - opts.ChunkPlanStoreFactory = func(string) (pipeline.ChunkPlanStore, error) { - return nil, errors.New("chunk plan store must not be constructed") - } command := append([]string(nil), args...) command = append(command, roots.config) var stdout, stderr bytes.Buffer diff --git a/internal/cli/recompute_execution_contract_test.go b/internal/cli/recompute_execution_contract_test.go deleted file mode 100644 index 1fe8f3b4..00000000 --- a/internal/cli/recompute_execution_contract_test.go +++ /dev/null @@ -1,338 +0,0 @@ -package cli - -import ( - "bytes" - "context" - "encoding/json" - "fmt" - "os" - "path/filepath" - "reflect" - "sort" - "strings" - "sync" - "testing" - - "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" - "gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline" -) - -func TestRecomputeStepRecoversThroughFilesystemCheckpoints(t *testing.T) { - tests := []struct { - name string - invalidateOutput bool - wantCode int - }{ - {name: "accepted producer is hydrated", wantCode: 0}, - {name: "invalid producer stops dependents", invalidateOutput: true, wantCode: 1}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - roots := newRecomputeTestRoots(t) - harness := newRecomputeTestHarness() - fresh := runRecomputeCommand(roots, harness.options(), false) - if fresh.code != 0 { - t.Fatalf("fresh run code=%d stderr=%q", fresh.code, fresh.stderr) - } - removeCheckpointLaneStage(t, roots.checkpoints, "extract", "first", "producer") - removeCheckpointLaneStage(t, roots.checkpoints, "merge", "first", "producer") - if tt.invalidateOutput { - path := findCheckpointFile(t, roots.checkpoints, "normalize", "first", "producer", "output.json") - if err := os.WriteFile(path, []byte("{"), 0o600); err != nil { - t.Fatal(err) - } - } - harness.resetCalls() - - resumed := runRecomputeCommand(roots, harness.options(), true) - if resumed.code != tt.wantCode { - t.Fatalf("resumed code=%d stdout=%q stderr=%q", resumed.code, resumed.stdout, resumed.stderr) - } - events := readLatestCheckpointEvents(t, roots.debug) - if tt.invalidateOutput { - if harness.callsFor("test/extract/middle") != 0 || harness.callsFor("test/extract/dependent") != 0 { - t.Fatalf("dependent calls after invalid producer = %#v", harness.callsSnapshot()) - } - if !strings.Contains(resumed.stderr, string(pipeline.CheckpointReasonDecodeFailed)) { - t.Fatalf("stderr=%q, want stable checkpoint reason", resumed.stderr) - } - assertNormalizeDecisionSequence(t, events, []checkpointDecisionExpectation{{"first", "producer", pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonDecodeFailed}}) - return - } - - if got := harness.callsSnapshot(); !reflect.DeepEqual(got, map[string]int{"test/extract/dependent": 1, "test/extract/middle": 1}) { - t.Fatalf("resumed extractor calls = %#v", got) - } - outputPath := filepath.Join(latestChildDir(t, roots.output), "result.json") - data, err := os.ReadFile(outputPath) - if err != nil { - t.Fatal(err) - } - if string(data) != "[\"producer\",\"unrelated\",\"middle\",\"dependent\"]\n" { - t.Fatalf("ordered output = %q", data) - } - assertNormalizeDecisionSequence(t, events, []checkpointDecisionExpectation{ - {"first", "producer", pipeline.CheckpointDecisionReused, pipeline.CheckpointReasonAcceptedArtifactReused}, - {"first", "unrelated", pipeline.CheckpointDecisionReused, pipeline.CheckpointReasonReused}, - {"second", "middle", pipeline.CheckpointDecisionForcedRecompute, pipeline.CheckpointReasonRecomputeStep}, - {"third", "dependent", pipeline.CheckpointDecisionForcedRecompute, pipeline.CheckpointReasonRecomputeStep}, - }) - }) - } -} - -type checkpointDecisionExpectation struct { - step, lane string - action pipeline.CheckpointDecisionCategory - reason pipeline.CheckpointReasonCode -} - -func assertNormalizeDecisionSequence(t *testing.T, events []pipeline.CheckpointEvent, want []checkpointDecisionExpectation) { - t.Helper() - var got []checkpointDecisionExpectation - for _, event := range events { - if event.Stage == string(pipeline.StageNormalize) { - got = append(got, checkpointDecisionExpectation{event.StepID, event.LaneID, event.Action, event.ReasonCode}) - } - } - if !reflect.DeepEqual(got, want) { - t.Fatalf("normalize decisions = %#v, want %#v", got, want) - } -} - -type recomputeTestHarness struct { - base *stateTestHarness - mu sync.Mutex - calls map[string]int -} - -func newRecomputeTestHarness() *recomputeTestHarness { - return &recomputeTestHarness{base: newStateTestHarness(), calls: make(map[string]int)} -} - -func (h *recomputeTestHarness) options() Options { - opts := h.base.options() - for _, key := range []string{"test/extract/producer", "test/extract/unrelated", "test/extract/middle", "test/extract/dependent"} { - moduleKey := key - spec := pipeline.ModuleSpec{ - Key: moduleKey, Stage: pipeline.StageExtract, ExecutionClass: contracts.ExecutionClassDeterministic, Requires: []string{"chunks"}, Provides: []string{"artifact"}, ArtifactKind: stateTestArtifactKind, - ReferenceSlots: []contracts.ReferenceSlot{{Name: "upstream", AcceptedMediaTypes: []string{"application/json"}, AcceptedArtifactKinds: []contracts.ArtifactKind{stateTestArtifactKind}}}, - } - if err := pipeline.RegisterExtractor(opts.Registries.Extractors, spec, func() (contracts.Extractor[stateTestArtifact], error) { - return recomputeTestExtractor{key: moduleKey, harness: h}, nil - }); err != nil { - panic(err) - } - } - if err := opts.Registries.Outputs.RegisterWithSpec(pipeline.ModuleSpec{Key: "test/recompute-output", Stage: pipeline.StageOutput, ExecutionClass: contracts.ExecutionClassDeterministic, Requires: []string{"normalized"}, Provides: []string{"output"}}, func() (contracts.OutputEncoder, error) { - return recomputeTestOutput{}, nil - }); err != nil { - panic(err) - } - opts.Catalog = catalogFromRegistries(opts.Registries) - return opts -} - -func (h *recomputeTestHarness) record(key string) { - h.mu.Lock() - defer h.mu.Unlock() - h.calls[key]++ -} - -func (h *recomputeTestHarness) resetCalls() { - h.mu.Lock() - defer h.mu.Unlock() - h.calls = make(map[string]int) -} - -func (h *recomputeTestHarness) callsFor(key string) int { - h.mu.Lock() - defer h.mu.Unlock() - return h.calls[key] -} - -func (h *recomputeTestHarness) callsSnapshot() map[string]int { - h.mu.Lock() - defer h.mu.Unlock() - result := make(map[string]int, len(h.calls)) - for key, value := range h.calls { - result[key] = value - } - return result -} - -type recomputeTestExtractor struct { - key string - harness *recomputeTestHarness -} - -func (e recomputeTestExtractor) Key() string { return e.key } -func (e recomputeTestExtractor) ReferenceSlots() []contracts.ReferenceSlot { - return []contracts.ReferenceSlot{{Name: "upstream", AcceptedMediaTypes: []string{"application/json"}, AcceptedArtifactKinds: []contracts.ArtifactKind{stateTestArtifactKind}}} -} -func (e recomputeTestExtractor) Extract(context.Context, contracts.TypedExtractionRequest) (contracts.TypedExtractionResult[stateTestArtifact], error) { - e.harness.record(e.key) - return contracts.TypedExtractionResult[stateTestArtifact]{Value: stateTestArtifact{Value: e.key}}, nil -} - -type recomputeTestOutput struct{} - -func (recomputeTestOutput) Key() string { return "test/recompute-output" } -func (recomputeTestOutput) Encode(_ context.Context, req contracts.OutputRequest) (contracts.OutputResult, error) { - lanes := make([]string, 0, len(req.NormalizeOutputs)) - for _, output := range req.NormalizeOutputs { - lanes = append(lanes, output.LaneID) - } - data, err := json.Marshal(lanes) - if err != nil { - return contracts.OutputResult{}, err - } - return contracts.OutputResult{Files: []contracts.OutputFile{{Name: "result.json", Bytes: append(data, '\n')}}}, nil -} - -func newRecomputeTestRoots(t *testing.T) stateTestRoots { - t.Helper() - roots := newStateTestRoots(t) - config := fmt.Sprintf(`version: 5 -output: - directory: %q -cache: - chunk_plans: - directory: %q - mode: bypass - checkpoints: - enabled: true - directory: %q -debug: - directory: %q -pipelines: - sample: - input: - module: test/input - chunk: - module: test/chunk - steps: - - id: first - artifacts: - producer: - extract: - module: test/extract/producer - merge: - module: test/merge - normalize: - module: test/normalize - unrelated: - extract: - module: test/extract/unrelated - merge: - module: test/merge - normalize: - module: test/normalize - - id: second - references: - upstream: - artifact: - step: first - lane: producer - artifacts: - middle: - extract: - module: test/extract/middle - merge: - module: test/merge - normalize: - module: test/normalize - - id: third - references: - upstream: - artifact: - step: second - lane: middle - artifacts: - dependent: - extract: - module: test/extract/dependent - merge: - module: test/merge - normalize: - module: test/normalize - output: - module: test/recompute-output -`, roots.output, roots.plans, roots.checkpoints, roots.debug) - if err := os.WriteFile(roots.config, []byte(config), 0o600); err != nil { - t.Fatal(err) - } - return roots -} - -func runRecomputeCommand(roots stateTestRoots, opts Options, recompute bool) stateTestResult { - args := []string{"run", "sample", "--config", roots.config, "--input", roots.input, "--chunk_cache", "bypass"} - if recompute { - args = append(args, "--resume", "--recompute-step", "second", "--debug") - } - var stdout, stderr bytes.Buffer - return stateTestResult{code: RunWithOptions(args, &stdout, &stderr, opts), stdout: stdout.String(), stderr: stderr.String()} -} - -func removeCheckpointLaneStage(t *testing.T, root, stage, step, lane string) { - t.Helper() - dir := filepath.Dir(findCheckpointFile(t, root, stage, step, lane, "manifest.json")) - if err := os.RemoveAll(dir); err != nil { - t.Fatal(err) - } -} - -func findCheckpointFile(t *testing.T, root, stage, step, lane, name string) string { - t.Helper() - want := filepath.Join(stage, step, lane, name) - var matches []string - err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error { - if err != nil { - return err - } - if !entry.IsDir() && strings.HasSuffix(path, want) { - matches = append(matches, path) - } - return nil - }) - if err != nil { - t.Fatal(err) - } - if len(matches) != 1 { - t.Fatalf("checkpoint files ending in %q = %v", want, matches) - } - return matches[0] -} - -func latestChildDir(t *testing.T, root string) string { - t.Helper() - entries, err := os.ReadDir(root) - if err != nil { - t.Fatal(err) - } - var dirs []string - for _, entry := range entries { - if entry.IsDir() { - dirs = append(dirs, filepath.Join(root, entry.Name())) - } - } - if len(dirs) == 0 { - t.Fatal("no child directory") - } - sort.Strings(dirs) - return dirs[len(dirs)-1] -} - -func readLatestCheckpointEvents(t *testing.T, root string) []pipeline.CheckpointEvent { - t.Helper() - var events []pipeline.CheckpointEvent - data, err := os.ReadFile(filepath.Join(latestChildDir(t, root), "summary", "checkpoint-events.json")) - if err != nil { - t.Fatal(err) - } - if err := json.Unmarshal(data, &events); err != nil { - t.Fatal(err) - } - return events -} diff --git a/internal/cli/recompute_policy_test.go b/internal/cli/recompute_policy_test.go deleted file mode 100644 index a9bc7e79..00000000 --- a/internal/cli/recompute_policy_test.go +++ /dev/null @@ -1,56 +0,0 @@ -package cli - -import ( - "testing" - - "gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline" -) - -func TestRecomputePolicyIncludesDependentLanesAndReusablePredecessors(t *testing.T) { - producer := pipeline.ResolvedArtifactLane{StepID: "first", ID: "producer"} - unrelated := pipeline.ResolvedArtifactLane{StepID: "first", ID: "unrelated"} - consumer := pipeline.ResolvedArtifactLane{ - StepID: "second", ID: "consumer", - ExtractReferences: pipeline.ResolvedReferenceTarget{Bindings: []pipeline.ReferenceBinding{{Artifact: &pipeline.ArtifactReference{Step: "first", Lane: "producer"}}}}, - } - downstream := pipeline.ResolvedArtifactLane{ - StepID: "third", ID: "downstream", - ExtractReferences: pipeline.ResolvedReferenceTarget{Bindings: []pipeline.ReferenceBinding{{Artifact: &pipeline.ArtifactReference{Step: "second", Lane: "consumer"}}}}, - } - independent := pipeline.ResolvedArtifactLane{StepID: "third", ID: "independent"} - resolved := pipeline.ResolvedPipeline{Steps: []pipeline.ResolvedPipelineStep{ - {ID: "first", ArtifactLanes: []pipeline.ResolvedArtifactLane{producer, unrelated}}, - {ID: "second", ArtifactLanes: []pipeline.ResolvedArtifactLane{consumer}}, - {ID: "third", ArtifactLanes: []pipeline.ResolvedArtifactLane{downstream, independent}}, - }} - - policy, err := recomputePolicy(resolved, "second") - if err != nil { - t.Fatal(err) - } - if _, ok := policy.ForcedLanes[pipeline.CheckpointLaneKey("second", "consumer")]; !ok { - t.Fatal("selected lane was not forced") - } - if _, ok := policy.ForcedLanes[pipeline.CheckpointLaneKey("third", "downstream")]; !ok { - t.Fatal("transitive dependent lane was not forced") - } - if _, ok := policy.ForcedLanes[pipeline.CheckpointLaneKey("first", "producer")]; ok { - t.Fatal("predecessor was implicitly forced") - } - if _, ok := policy.RequireReusableLanes[pipeline.CheckpointLaneKey("first", "producer")]; !ok { - t.Fatal("required predecessor was not marked reusable") - } - if _, ok := policy.ForcedLanes[pipeline.CheckpointLaneKey("first", "unrelated")]; ok { - t.Fatal("unrelated lane was forced") - } - if _, ok := policy.ForcedLanes[pipeline.CheckpointLaneKey("third", "independent")]; ok { - t.Fatal("unrelated later lane was forced") - } -} - -func TestRecomputePolicyRejectsUnknownStep(t *testing.T) { - _, err := recomputePolicy(pipeline.ResolvedPipeline{Steps: []pipeline.ResolvedPipelineStep{{ID: "known"}}}, "missing") - if err == nil { - t.Fatal("unknown step was accepted") - } -} diff --git a/internal/cli/run.go b/internal/cli/run.go index 065d2818..b50aa08d 100644 --- a/internal/cli/run.go +++ b/internal/cli/run.go @@ -20,8 +20,7 @@ import ( "gitea.maximumdirect.net/eric/notarius/internal/core/config" "gitea.maximumdirect.net/eric/notarius/internal/core/debugbundle" "gitea.maximumdirect.net/eric/notarius/internal/core/fileio" - "gitea.maximumdirect.net/eric/notarius/internal/framework/checkpoint" - "gitea.maximumdirect.net/eric/notarius/internal/framework/chunkplan" + "gitea.maximumdirect.net/eric/notarius/internal/framework/artifactcache" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" frameworkdebug "gitea.maximumdirect.net/eric/notarius/internal/framework/debug" frameworkllm "gitea.maximumdirect.net/eric/notarius/internal/framework/llm" @@ -32,19 +31,18 @@ import ( ) type Options struct { - LLMClient promptkit.LLMClient - LLMRuntime promptkit.RuntimeConfig - Catalog pipeline.ModuleCatalog - Registries pipeline.Registries - LLMClientFactory LLMClientFactory - RunIDGenerator RunIDGenerator - LookupEnv func(string) (string, bool) - Now func() time.Time - UserCacheDir func() (string, error) - ChunkPlanStoreFactory pipeline.ChunkPlanStoreFactory - DebugRecorderFactory func(string) (pipeline.DebugRecorder, error) - DebugTerminalFactory func(*debugbundle.SummaryWriter) DebugTerminalWriter - promptKitAssets *frameworkllm.AssetRegistry + LLMClient promptkit.LLMClient + LLMRuntime promptkit.RuntimeConfig + Catalog pipeline.ModuleCatalog + Registries pipeline.Registries + LLMClientFactory LLMClientFactory + RunIDGenerator RunIDGenerator + LookupEnv func(string) (string, bool) + Now func() time.Time + UserCacheDir func() (string, error) + DebugRecorderFactory func(string) (pipeline.DebugRecorder, error) + DebugTerminalFactory func(*debugbundle.SummaryWriter) DebugTerminalWriter + promptKitAssets *frameworkllm.AssetRegistry } type LLMRuntimeOverrides struct { @@ -85,9 +83,6 @@ func normalizeOptions(opts Options) (Options, error) { if opts.UserCacheDir == nil { opts.UserCacheDir = os.UserCacheDir } - if opts.ChunkPlanStoreFactory == nil { - opts.ChunkPlanStoreFactory = chunkplan.NewFilesystemStore - } if opts.DebugRecorderFactory == nil { opts.DebugRecorderFactory = frameworkdebug.NewFilesystemRecorder } @@ -130,19 +125,14 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i llmProfile := singleValueFlag{name: "--llm-profile"} reasoningEffort := singleValueFlag{name: "--reasoning-effort"} clearReasoningEffort := fs.Bool("clear-reasoning-effort", false, "clear the LLM profile reasoning effort") - resume := fs.Bool("resume", false, "reuse compatible recorded checkpoints") - recomputeStep := singleValueFlag{name: "--recompute-step"} - chunkCache := chunkCacheFlag{} requestedSessionID := sessionIDFlag{} referenceFlags := stringListFlag{} withoutReferenceFlags := stringListFlag{} fs.Var(&requestedSessionID, "session-id", "prompt session identifier") fs.Var(&llmProfile, "llm-profile", "LLM profile override") fs.Var(&reasoningEffort, "reasoning-effort", "reasoning effort override") - fs.Var(&chunkCache, "chunk_cache", "chunk plan cache mode: auto, bypass, or refresh") fs.Var(&referenceFlags, "reference", "reference binding, as slot=path, chunk.slot=path, lane.slot=path, lane.extract.slot=path, lane.merge.slot=path, or lane.normalize.slot=path") fs.Var(&withoutReferenceFlags, "without-reference", "unbind a reference, using the same selector forms as --reference") - fs.Var(&recomputeStep, "recompute-step", "recompute one ordered pipeline step and dependent lanes") if err := validateRunFlagValues(args); err != nil { fmt.Fprintf(stderr, "notarius: %v\n", err) return 2 @@ -209,14 +199,6 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i fmt.Fprintf(stderr, "notarius: %v\n", err) return 2 } - if recomputeStep.set && strings.TrimSpace(recomputeStep.value) == "" { - fmt.Fprintln(stderr, "notarius: --recompute-step must not be empty") - return 2 - } - if recomputeStep.set && len(only) > 0 { - fmt.Fprintln(stderr, "notarius: --recompute-step cannot be combined with --only") - return 2 - } referenceRequests, err := parseReferenceFlags(referenceFlags) if err != nil { fmt.Fprintf(stderr, "notarius: %v\n", err) @@ -228,7 +210,7 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i return 2 } - loaded, loadedConfigPath, err := loadConfigKit(*configPath, *configOverlay, runConfigurationOverrides(chunkCache, *outputDir, *debugDir), opts) + loaded, loadedConfigPath, err := loadConfigKit(*configPath, *configOverlay, runConfigurationOverrides(*outputDir, *debugDir), opts) if err != nil { writeConfigLoadError(stderr, err) return 1 @@ -238,19 +220,6 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i fmt.Fprintf(stderr, "notarius: %v\n", err) return 1 } - if *resume && !cfg.Cache.Checkpoints.Enabled { - fmt.Fprintln(stderr, "notarius: --resume requires cache.checkpoints.enabled: true") - return 1 - } - if recomputeStep.set && !*resume { - fmt.Fprintln(stderr, "notarius: --recompute-step requires --resume") - return 2 - } - if recomputeStep.set && !cfg.Cache.Checkpoints.Enabled { - fmt.Fprintln(stderr, "notarius: --recompute-step requires cache.checkpoints.enabled: true") - return 1 - } - startedAt := opts.Now().UTC() runID, err := opts.RunIDGenerator(startedAt) if err != nil { @@ -293,10 +262,7 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i ConfigSource: configSource(*configPath), ConfigOverlay: effectiveConfigOverlay(*configOverlay), OnlyLanes: append([]string(nil), only...), - ChunkCacheOverride: chunkCache.explicitValue(), ReasoningEffortOverride: runtimeOverrides.ReasoningEffort, - Resume: *resume, - RecomputeStep: strings.TrimSpace(recomputeStep.value), RunID: runID, StartedAt: startedAt, } @@ -339,13 +305,6 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i return failPipelineCommand(stderr, commandState, terminalWriter, err) } effective.ResolvedPipeline = materialized - checkpointPolicy := pipeline.CheckpointExecutionPolicy{} - if recomputeStep.set { - checkpointPolicy, err = recomputePolicy(effective.ResolvedPipeline, recomputeStep.value) - if err != nil { - return failPipelineCommand(stderr, commandState, terminalWriter, err) - } - } invocation.PipelineDigest = effective.ResolvedPipeline.Digest if err := writeSummary(summary, func() error { return summary.WriteInvocation(invocation) }); err != nil { return failPipelineCommand(stderr, commandState, terminalWriter, fmt.Errorf("write debug invocation metadata: %w", err)) @@ -376,13 +335,6 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i if err != nil { return failPipelineCommand(stderr, commandState, terminalWriter, fmt.Errorf("create LLM client for profile %q: %w", factoryProfileID, err)) } - var llmFingerprints []checkpoint.Fingerprint - if effective.Config.Cache.Checkpoints.Enabled { - llmFingerprints, err = llmCheckpointFingerprints(llmClient) - if err != nil { - return failPipelineCommand(stderr, commandState, terminalWriter, fmt.Errorf("prepare LLM checkpoint identity: %w", err)) - } - } llmClient = pipeline.WithDebugLLMRecording(llmClient, debugRecorder) prepared, err := pipeline.Prepare(effective.ResolvedPipeline, registries, pipeline.ModuleDependencies{LLM: llmClient}) if err != nil { @@ -400,32 +352,24 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i if err := writeSummary(summary, func() error { return summary.WriteInvocation(invocation) }); err != nil { return failPipelineCommand(stderr, commandState, terminalWriter, fmt.Errorf("write debug invocation metadata: %w", err)) } - chunkPlans, err := chunkPlanStoreForRun(effective.Config.Cache.ChunkPlans, opts) - if err != nil { - return failPipelineCommand(stderr, commandState, terminalWriter, err) - } - checkpointRecorder, checkpointLoader, err := checkpointHandlersForRun(effective.Config.Cache.Checkpoints, opts, effective.ResolvedPipeline, prepared.CheckpointFingerprints(), llmFingerprints, rawInput, only, llmProfiles, strings.TrimSpace(llmProfile.value), effectiveSessionID, runtimeOverrides, *resume) + cache, err := artifactcache.NewFilesystemStore(effective.Config.CacheDirectory) if err != nil { return failPipelineCommand(stderr, commandState, terminalWriter, err) } output, err := pipeline.New().Run(ctx, pipeline.RunInput{ - Prepared: prepared, - Path: strings.TrimSpace(*inputPath), - RawInput: rawInput, - SessionID: effectiveSessionID, - RunID: runID, - StartedAt: startedAt, - LLMProfiles: llmProfiles, - Metadata: runMetadata(effective.Config.Output.Directory, debugPath), - Diagnostics: referenceDiagnostics, - ChunkCacheMode: effective.Config.Cache.ChunkPlans.Mode, - ChunkPlans: chunkPlans, - Checkpoints: checkpointRecorder, - Checkpoint: checkpointLoader, - CheckpointPolicy: checkpointPolicy, - Debug: debugRecorder, - Workers: cfg.Concurrency.Workers, + Prepared: prepared, + Path: strings.TrimSpace(*inputPath), + RawInput: rawInput, + SessionID: effectiveSessionID, + RunID: runID, + StartedAt: startedAt, + LLMProfiles: llmProfiles, + Metadata: runMetadata(effective.Config.Output.Directory, debugPath), + Diagnostics: referenceDiagnostics, + Cache: cache, + Debug: debugRecorder, + Workers: cfg.Concurrency.Workers, }) diagnosticProjection, diagnosticErr := contracts.ProjectDiagnosticCollection(output.Diagnostics) if diagnosticErr == nil { @@ -511,196 +455,10 @@ func writePartialSummary(summary *debugbundle.SummaryWriter, output pipeline.Run if err := summary.WriteRunManifest(output.Manifest); err != nil { return err } - if output.ChunkPlan != nil { - if err := summary.WriteChunkPlan(*output.ChunkPlan); err != nil { - return err - } - } if err := summary.WriteDiagnostics(output.Diagnostics); err != nil { return err } - return summary.WriteCheckpointEvents(output.CheckpointEvents) -} - -func checkpointHandlersForRun( - settings config.CheckpointCacheConfig, - opts Options, - resolved pipeline.ResolvedPipeline, - componentFingerprints []pipeline.CheckpointFingerprint, - llmFingerprints []checkpoint.Fingerprint, - rawInput []byte, - only []string, - llmProfiles []artifacts.LLMProfileManifest, - llmProfileOverride string, - sessionID string, - runtimeOverrides LLMRuntimeOverrides, - resume bool, -) (pipeline.CheckpointRecorder, pipeline.CheckpointLoader, error) { - if !settings.Enabled { - if resume { - return nil, nil, fmt.Errorf("--resume requires cache.checkpoints.enabled: true") - } - return pipeline.NoopCheckpointRecorder(), pipeline.NoopCheckpointLoader(), nil - } - identity, err := checkpoint.NewIdentity(checkpoint.IdentityInput{ - Pipeline: resolved, - InputKey: resolved.Input.Module, - RawInputDigest: rawInputDigest(rawInput), - SelectedLanes: only, - RuntimeOverrides: runtimeOverrideFingerprints(llmProfileOverride, sessionID, runtimeOverrides), - References: pipeline.ReferenceProvenance(resolved), - ProvenanceFingerprints: combineCheckpointFingerprints( - llmProfileFingerprints(llmProfiles), - llmFingerprints, - checkpointIdentityFingerprints(componentFingerprints), - ), - }) - if err != nil { - return nil, nil, fmt.Errorf("create checkpoint identity: %w", err) - } - checkpointRoot := strings.TrimSpace(settings.Directory) - if checkpointRoot == "" { - checkpointRoot, err = config.DefaultCheckpointRoot(opts.UserCacheDir) - if err != nil { - return nil, nil, fmt.Errorf("resolve checkpoint root: %w", err) - } - } - recorder, err := checkpoint.NewFilesystemRecorder(checkpointRoot, identity) - if err != nil { - return nil, nil, fmt.Errorf("create checkpoint recorder: %w", err) - } - loader := pipeline.NoopCheckpointLoader() - if resume { - loader, err = checkpoint.NewFilesystemLoader(checkpointRoot, identity) - if err != nil { - return nil, nil, fmt.Errorf("create checkpoint loader: %w", err) - } - } - return recorder, loader, nil -} - -func llmCheckpointFingerprints(client contracts.StructuredLLMClient) ([]checkpoint.Fingerprint, error) { - provider, ok := client.(frameworkllm.CheckpointFingerprintProvider) - if !ok { - return nil, nil - } - values, err := provider.LLMCheckpointFingerprints() - if err != nil { - return nil, err - } - out := make([]checkpoint.Fingerprint, 0, len(values)) - for _, value := range values { - out = append(out, checkpoint.Fingerprint{Name: value.Name, Value: value.Value}) - } - return out, nil -} - -func combineCheckpointFingerprints(sources ...[]checkpoint.Fingerprint) []checkpoint.Fingerprint { - var out []checkpoint.Fingerprint - for _, source := range sources { - out = append(out, source...) - } - return out -} - -func recomputePolicy(resolved pipeline.ResolvedPipeline, requestedStep string) (pipeline.CheckpointExecutionPolicy, error) { - requestedStep = strings.TrimSpace(requestedStep) - if requestedStep == "" { - return pipeline.CheckpointExecutionPolicy{}, fmt.Errorf("--recompute-step must not be empty") - } - var selected *pipeline.ResolvedPipelineStep - for index := range resolved.Steps { - if strings.TrimSpace(resolved.Steps[index].ID) == requestedStep { - selected = &resolved.Steps[index] - break - } - } - if selected == nil { - return pipeline.CheckpointExecutionPolicy{}, fmt.Errorf("unknown pipeline step %q", requestedStep) - } - - policy := pipeline.CheckpointExecutionPolicy{ForcedLanes: make(map[string]struct{}), RequireReusableLanes: make(map[string]struct{})} - var forced []pipeline.ResolvedArtifactLane - for _, lane := range selected.ArtifactLanes { - lane.StepID = selected.ID - policy.ForcedLanes[pipeline.CheckpointLaneKey(selected.ID, lane.ID)] = struct{}{} - forced = append(forced, lane) - } - - lanes := make(map[string]pipeline.ResolvedArtifactLane) - dependents := make(map[string][]pipeline.ResolvedArtifactLane) - for _, step := range resolved.Steps { - for _, lane := range step.ArtifactLanes { - lane.StepID = step.ID - lanes[pipeline.CheckpointLaneKey(step.ID, lane.ID)] = lane - for _, target := range []pipeline.ResolvedReferenceTarget{lane.ExtractReferences, lane.MergeReferences, lane.NormalizeReferences} { - for _, binding := range target.Bindings { - if binding.Artifact != nil { - producerKey := pipeline.CheckpointLaneKey(binding.Artifact.Step, binding.Artifact.Lane) - dependents[producerKey] = append(dependents[producerKey], lane) - } - } - } - } - } - processed := make(map[string]struct{}) - queue := append([]pipeline.ResolvedArtifactLane(nil), forced...) - for len(queue) > 0 { - lane := queue[0] - queue = queue[1:] - key := pipeline.CheckpointLaneKey(lane.StepID, lane.ID) - if _, ok := processed[key]; ok { - continue - } - processed[key] = struct{}{} - for _, dependent := range dependents[key] { - dependentKey := pipeline.CheckpointLaneKey(dependent.StepID, dependent.ID) - if _, alreadyForced := policy.ForcedLanes[dependentKey]; alreadyForced { - continue - } - policy.ForcedLanes[dependentKey] = struct{}{} - forced = append(forced, dependent) - queue = append(queue, dependent) - } - } - - processed = make(map[string]struct{}) - queue = append([]pipeline.ResolvedArtifactLane(nil), forced...) - for len(queue) > 0 { - lane := queue[0] - queue = queue[1:] - key := pipeline.CheckpointLaneKey(lane.StepID, lane.ID) - if _, ok := processed[key]; ok { - continue - } - processed[key] = struct{}{} - for _, target := range []pipeline.ResolvedReferenceTarget{lane.ExtractReferences, lane.MergeReferences, lane.NormalizeReferences} { - for _, binding := range target.Bindings { - if binding.Artifact == nil { - continue - } - producerKey := pipeline.CheckpointLaneKey(binding.Artifact.Step, binding.Artifact.Lane) - if _, forcedAlready := policy.ForcedLanes[producerKey]; !forcedAlready { - policy.RequireReusableLanes[producerKey] = struct{}{} - } - if producer, ok := lanes[producerKey]; ok { - queue = append(queue, producer) - } - } - } - } - return policy, nil -} - -func checkpointIdentityFingerprints(values []pipeline.CheckpointFingerprint) []checkpoint.Fingerprint { - if len(values) == 0 { - return nil - } - out := make([]checkpoint.Fingerprint, len(values)) - for index, value := range values { - out[index] = checkpoint.Fingerprint{Name: "component:" + value.Name, Value: value.Value} - } - return out + return nil } func rawInputDigest(data []byte) string { @@ -708,42 +466,6 @@ func rawInputDigest(data []byte) string { return "sha256:" + hex.EncodeToString(sum[:]) } -func runtimeOverrideFingerprints(llmProfileOverride string, sessionID string, runtimeOverrides LLMRuntimeOverrides) []checkpoint.Fingerprint { - var values []checkpoint.Fingerprint - if strings.TrimSpace(llmProfileOverride) != "" { - values = append(values, checkpoint.Fingerprint{Name: "llm_profile_override", Value: strings.TrimSpace(llmProfileOverride)}) - } - if strings.TrimSpace(sessionID) != "" { - values = append(values, checkpoint.Fingerprint{Name: "session_id", Value: strings.TrimSpace(sessionID)}) - } - if runtimeOverrides.ReasoningEffort != nil { - value := strings.TrimSpace(*runtimeOverrides.ReasoningEffort) - if value == "" { - value = "" - } - values = append(values, checkpoint.Fingerprint{Name: "reasoning_effort_override", Value: value}) - } - return values -} - -func llmProfileFingerprints(profiles []artifacts.LLMProfileManifest) []checkpoint.Fingerprint { - if len(profiles) == 0 { - return nil - } - values := make([]checkpoint.Fingerprint, 0, len(profiles)) - for _, profile := range profiles { - id := strings.TrimSpace(profile.ID) - if id == "" { - continue - } - values = append(values, checkpoint.Fingerprint{ - Name: "llm_profile:" + id, - Value: strings.TrimSpace(profile.Provider) + ":" + strings.TrimSpace(profile.Model), - }) - } - return values -} - func configSource(configPath string) string { if strings.TrimSpace(configPath) != "" { return "flag" @@ -837,22 +559,15 @@ func reorderRunArgs(args []string) []string { func runFlagTakesValue(arg string) bool { switch arg { - case "--config", "--config-overlay", "--input", "--only", "--output-dir", "--debug-dir", "--llm-profile", "--session-id", "--reasoning-effort", "--chunk_cache", "--reference", "--without-reference", "--recompute-step": + case "--config", "--config-overlay", "--input", "--only", "--output-dir", "--debug-dir", "--llm-profile", "--session-id", "--reasoning-effort", "--reference", "--without-reference": return true default: return false } } -func runConfigurationOverrides(chunkCache chunkCacheFlag, outputDir, debugDir string) []configkit.Override { +func runConfigurationOverrides(outputDir, debugDir string) []configkit.Override { overrides := make([]configkit.Override, 0, 3) - if chunkCache.set { - overrides = append(overrides, configkit.Override{ - Path: configkit.Keys("cache", "chunk_plans", "mode"), - Value: string(chunkCache.value), - Flag: "--chunk_cache", - }) - } if outputDir = strings.TrimSpace(outputDir); outputDir != "" { overrides = append(overrides, configkit.Override{ Path: configkit.Keys("output", "directory"), @@ -870,57 +585,6 @@ func runConfigurationOverrides(chunkCache chunkCacheFlag, outputDir, debugDir st return overrides } -type chunkCacheFlag struct { - value pipeline.ChunkCacheMode - set bool -} - -func (f *chunkCacheFlag) String() string { - if f == nil { - return "" - } - return string(f.value) -} - -func (f *chunkCacheFlag) Set(raw string) error { - mode, err := pipeline.ParseChunkCacheMode(raw) - if err != nil { - return err - } - f.value = mode - f.set = true - return nil -} - -func (f chunkCacheFlag) explicitValue() string { - if !f.set { - return "" - } - return string(f.value) -} - -func chunkPlanStoreForRun(cfg config.ChunkPlanCacheConfig, opts Options) (pipeline.ChunkPlanStore, error) { - if cfg.Mode == pipeline.ChunkCacheBypass { - return nil, nil - } - root := strings.TrimSpace(cfg.Directory) - if root == "" { - var err error - root, err = config.DefaultChunkPlanRoot(opts.UserCacheDir) - if err != nil { - return nil, fmt.Errorf("resolve chunk plan root: %w", err) - } - } - store, err := opts.ChunkPlanStoreFactory(root) - if err != nil { - return nil, fmt.Errorf("create chunk plan store at %q: %w", root, err) - } - if store == nil { - return nil, fmt.Errorf("create chunk plan store at %q: factory returned nil", root) - } - return store, nil -} - func validateRunFlagValues(args []string) error { for i, arg := range args { if arg != "--config-overlay" && arg != "--session-id" && arg != "--reasoning-effort" { diff --git a/internal/framework/pipeline/checkpoint.go b/internal/framework/pipeline/checkpoint.go deleted file mode 100644 index 63a62246..00000000 --- a/internal/framework/pipeline/checkpoint.go +++ /dev/null @@ -1,504 +0,0 @@ -package pipeline - -import ( - "crypto/sha256" - "encoding/hex" - "fmt" - "sort" - "strings" - - "gitea.maximumdirect.net/eric/notarius/internal/core/source" - "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" -) - -type CheckpointFingerprint struct { - Name string `json:"name"` - Value string `json:"value"` -} - -// CheckpointFingerprintProvider supplies stable, non-secret semantic identity -// for a prepared module or validator. Values must not contain source content, -// credentials, local paths, timestamps, or other invocation-specific data. -type CheckpointFingerprintProvider interface { - CheckpointFingerprints() []CheckpointFingerprint -} - -type CheckpointRecorder interface { - SourceRunning(moduleKey string) error - SourceSucceeded(moduleKey string, doc *source.SourceDocument) error - SourceFailed(moduleKey string, err error) error - ExtractRunning(laneID string, moduleKey string, dependencies []CheckpointFingerprint) error - ExtractSucceeded(laneID string, moduleKey string, dependencies []CheckpointFingerprint, outputs []CheckpointArtifact, rejected []contracts.RejectedOutput) error - ExtractFailed(laneID string, moduleKey string, dependencies []CheckpointFingerprint, err error) error - MergeRunning(laneID string, moduleKey string, dependencies []CheckpointFingerprint) error - MergeSucceeded(laneID string, moduleKey string, dependencies []CheckpointFingerprint, output CheckpointArtifact) error - MergeRejected(laneID string, moduleKey string, dependencies []CheckpointFingerprint, rejected contracts.RejectedOutput) error - MergeFailed(laneID string, moduleKey string, dependencies []CheckpointFingerprint, err error) error - NormalizeRunning(laneID string, moduleKey string, dependencies []CheckpointFingerprint) error - NormalizeSucceeded(laneID string, moduleKey string, dependencies []CheckpointFingerprint, output CheckpointArtifact) error - NormalizeRejected(laneID string, moduleKey string, dependencies []CheckpointFingerprint, rejected contracts.RejectedOutput) error - NormalizeFailed(laneID string, moduleKey string, dependencies []CheckpointFingerprint, err error) error -} - -// StepCheckpointRecorder is implemented by checkpoint stores that isolate -// lane artifacts by their ordered pipeline step. The legacy recorder methods -// remain available for callers that do not have step context. -type StepCheckpointRecorder interface { - ExtractRunningForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint) error - ExtractSucceededForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, outputs []CheckpointArtifact, rejected []contracts.RejectedOutput) error - ExtractFailedForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, err error) error - MergeRunningForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint) error - MergeSucceededForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, output CheckpointArtifact) error - MergeRejectedForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, rejected contracts.RejectedOutput) error - MergeFailedForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, err error) error - NormalizeRunningForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint) error - NormalizeSucceededForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, output CheckpointArtifact) error - NormalizeRejectedForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, rejected contracts.RejectedOutput) error - NormalizeFailedForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint, err error) error -} - -type CheckpointDecisionCategory string - -const ( - CheckpointDecisionExecuted CheckpointDecisionCategory = "executed" - CheckpointDecisionReused CheckpointDecisionCategory = "reused" - CheckpointDecisionForcedRecompute CheckpointDecisionCategory = "forced_recompute" - CheckpointDecisionDependencyInvalidated CheckpointDecisionCategory = "dependency_invalidated" -) - -type CheckpointReasonCode string - -const ( - CheckpointReasonLoadingDisabled CheckpointReasonCode = "loading_disabled" - CheckpointReasonMissing CheckpointReasonCode = "checkpoint_missing" - CheckpointReasonPathInvalid CheckpointReasonCode = "checkpoint_path_invalid" - CheckpointReasonReadFailed CheckpointReasonCode = "checkpoint_read_failed" - CheckpointReasonDecodeFailed CheckpointReasonCode = "checkpoint_decode_failed" - CheckpointReasonWorkspaceSchemaIncompatible CheckpointReasonCode = "workspace_schema_incompatible" - CheckpointReasonIdentityMismatch CheckpointReasonCode = "identity_mismatch" - CheckpointReasonStageMismatch CheckpointReasonCode = "stage_mismatch" - CheckpointReasonStepMismatch CheckpointReasonCode = "step_mismatch" - CheckpointReasonLaneMismatch CheckpointReasonCode = "lane_mismatch" - CheckpointReasonModuleMismatch CheckpointReasonCode = "module_mismatch" - CheckpointReasonStatusNotReusable CheckpointReasonCode = "status_not_reusable" - CheckpointReasonDependencyMismatch CheckpointReasonCode = "dependency_mismatch" - CheckpointReasonArtifactPayloadInvalid CheckpointReasonCode = "artifact_payload_invalid" - CheckpointReasonArtifactDigestMismatch CheckpointReasonCode = "artifact_digest_mismatch" - CheckpointReasonArtifactCodecIncompatible CheckpointReasonCode = "artifact_codec_incompatible" - CheckpointReasonArtifactNotCanonical CheckpointReasonCode = "artifact_not_canonical" - CheckpointReasonReused CheckpointReasonCode = "checkpoint_reused" - CheckpointReasonAcceptedArtifactReused CheckpointReasonCode = "accepted_artifact_reused" - CheckpointReasonRecomputeStep CheckpointReasonCode = "recompute_step" - CheckpointReasonValidationIncompleteLineage CheckpointReasonCode = "validation_incomplete_lineage" -) - -type CheckpointDecision struct { - Reused bool `json:"reused"` - Category CheckpointDecisionCategory `json:"category,omitempty"` - ReasonCode CheckpointReasonCode `json:"reason_code,omitempty"` - Detail string `json:"detail,omitempty"` - // Reason is retained as a compatibility/debug field for existing callers. - // Detail and Reason are derived from the stable reason code. - Reason string `json:"reason,omitempty"` -} - -const checkpointDecisionDetailLimit = 512 - -func NewCheckpointDecision(category CheckpointDecisionCategory, reasonCode CheckpointReasonCode) CheckpointDecision { - return checkpointDecision(category, reasonCode) -} - -func checkpointDecision(category CheckpointDecisionCategory, reasonCode CheckpointReasonCode) CheckpointDecision { - detail := normalizeCheckpointDecisionDetail(checkpointDecisionDetail(reasonCode)) - return CheckpointDecision{ - Reused: category == CheckpointDecisionReused, - Category: category, - ReasonCode: reasonCode, - Detail: detail, - Reason: detail, - } -} - -func checkpointDecisionDetail(reasonCode CheckpointReasonCode) string { - switch reasonCode { - case CheckpointReasonLoadingDisabled: - return "checkpoint loading is disabled" - case CheckpointReasonMissing: - return "checkpoint artifact is missing" - case CheckpointReasonPathInvalid: - return "checkpoint location is invalid" - case CheckpointReasonReadFailed: - return "checkpoint artifact could not be read" - case CheckpointReasonDecodeFailed: - return "checkpoint artifact could not be decoded" - case CheckpointReasonWorkspaceSchemaIncompatible: - return "checkpoint workspace schema is incompatible" - case CheckpointReasonIdentityMismatch: - return "checkpoint identity does not match the current invocation" - case CheckpointReasonStageMismatch: - return "checkpoint stage does not match" - case CheckpointReasonStepMismatch: - return "checkpoint step does not match" - case CheckpointReasonLaneMismatch: - return "checkpoint lane does not match" - case CheckpointReasonModuleMismatch: - return "checkpoint module does not match" - case CheckpointReasonStatusNotReusable: - return "checkpoint status is not reusable" - case CheckpointReasonDependencyMismatch: - return "checkpoint dependencies do not match" - case CheckpointReasonArtifactPayloadInvalid: - return "checkpoint artifact payload is invalid" - case CheckpointReasonArtifactDigestMismatch: - return "checkpoint artifact digest does not match" - case CheckpointReasonArtifactCodecIncompatible: - return "checkpoint artifact is incompatible with the registered codec" - case CheckpointReasonArtifactNotCanonical: - return "checkpoint artifact is not canonical" - case CheckpointReasonReused: - return "checkpoint is reusable" - case CheckpointReasonAcceptedArtifactReused: - return "accepted normalized artifact is reusable" - case CheckpointReasonRecomputeStep: - return "selected step requires execution" - case CheckpointReasonValidationIncompleteLineage: - return "checkpoint reuse is disabled by validation-incomplete input lineage" - default: - return "checkpoint decision" - } -} - -func normalizeCheckpointDecisionDetail(detail string) string { - detail = strings.TrimSpace(strings.ToValidUTF8(detail, "?")) - var b strings.Builder - for _, r := range detail { - if r < 0x20 || r == 0x7f { - r = ' ' - } - if b.Len()+len(string(r)) > checkpointDecisionDetailLimit { - break - } - b.WriteRune(r) - } - return strings.Join(strings.Fields(b.String()), " ") -} - -type CheckpointEvent struct { - Stage string `json:"stage"` - StepID string `json:"step_id,omitempty"` - LaneID string `json:"lane_id,omitempty"` - ModuleKey string `json:"module_key,omitempty"` - Action CheckpointDecisionCategory `json:"action"` - Category CheckpointDecisionCategory `json:"category,omitempty"` - ReasonCode CheckpointReasonCode `json:"reason_code,omitempty"` - Detail string `json:"detail,omitempty"` - Reason string `json:"reason,omitempty"` -} - -type CheckpointExecutionPolicy struct { - ForcedLanes map[string]struct{} - RequireReusableLanes map[string]struct{} -} - -func CheckpointLaneKey(stepID, laneID string) string { - return strings.TrimSpace(stepID) + "\x00" + strings.TrimSpace(laneID) -} - -func (policy CheckpointExecutionPolicy) forced(stepID, laneID string) bool { - _, ok := policy.ForcedLanes[CheckpointLaneKey(stepID, laneID)] - return ok -} - -func (policy CheckpointExecutionPolicy) requiresReusable(stepID, laneID string) bool { - _, ok := policy.RequireReusableLanes[CheckpointLaneKey(stepID, laneID)] - return ok -} - -func forceCheckpointDecision(policy CheckpointExecutionPolicy, stepID, laneID string, decision CheckpointDecision) CheckpointDecision { - if policy.forced(stepID, laneID) { - return checkpointDecision(CheckpointDecisionForcedRecompute, CheckpointReasonRecomputeStep) - } - return decision -} - -func requireReusableCheckpoint(policy CheckpointExecutionPolicy, stepID, laneID string, decision CheckpointDecision) error { - if policy.requiresReusable(stepID, laneID) && !policy.forced(stepID, laneID) && !decision.Reused { - return fmt.Errorf("required reusable checkpoint unavailable for step %q lane %q (%s)", strings.TrimSpace(stepID), strings.TrimSpace(laneID), decision.ReasonCode) - } - return nil -} - -// resolveCheckpointDecision applies runner policy and canonical payload -// validation at the single point where a stage's observable decision is made. -type checkpointResolution struct { - decision CheckpointDecision - values []any - artifacts []CheckpointArtifact -} - -func resolveCheckpointDecision(output *RunOutput, loader CheckpointLoader, policy CheckpointExecutionPolicy, stage ModuleStage, stepID, laneID, moduleKey string, decision CheckpointDecision, codec artifactCodecEntry, artifacts []CheckpointArtifact) (checkpointResolution, error) { - decision = forceCheckpointDecision(policy, stepID, laneID, decision) - resolution := checkpointResolution{decision: decision} - if decision.Reused { - resolution.values = make([]any, 0, len(artifacts)) - resolution.artifacts = make([]CheckpointArtifact, 0, len(artifacts)) - for _, artifact := range artifacts { - value, hydrated, err := decodeCanonicalCheckpointArtifact(codec, artifact) - if err != nil { - decision = checkpointDecision(CheckpointDecisionExecuted, checkpointArtifactReasonCode(err)) - resolution.values = nil - resolution.artifacts = nil - break - } - resolution.values = append(resolution.values, value) - resolution.artifacts = append(resolution.artifacts, hydrated) - } - } - resolution.decision = decision - if output != nil { - recordCheckpointEvent(output, loader, string(stage), stepID, laneID, moduleKey, decision) - } - if err := requireReusableCheckpoint(policy, stepID, laneID, decision); err != nil { - return resolution, err - } - return resolution, nil -} - -type SourceCheckpoint struct { - Document *source.SourceDocument -} - -// CheckpointArtifact is the durable, domain-neutral value stored at a lane -// checkpoint boundary. -type CheckpointArtifact struct { - LaneID string - ModuleKey string - SourceID string - ChunkID string - ChunkIndex int - ChunkRef source.SourceRef - Artifact contracts.SerializedArtifact - SchemaDigest string - Diagnostics []CheckpointDiagnostic -} - -// CheckpointDiagnostic stores a producer-local diagnostic alongside a -// reusable artifact. The runner supplies the current run's origin when it -// promotes this value into a diagnostic group. -type CheckpointDiagnostic struct { - Diagnostic contracts.ProducerDiagnostic `json:"diagnostic"` - ValidatorKey string `json:"validator_key,omitempty"` -} - -type ExtractCheckpoint struct { - Outputs []CheckpointArtifact - Rejected []contracts.RejectedOutput -} - -type MergeCheckpoint struct { - Output CheckpointArtifact -} -type NormalizeCheckpoint struct { - Output CheckpointArtifact -} - -type CheckpointLoader interface { - Enabled() bool - Source(moduleKey string) (SourceCheckpoint, CheckpointDecision) - Extract(laneID string, moduleKey string, dependencies []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) - Merge(laneID string, moduleKey string, dependencies []CheckpointFingerprint) (MergeCheckpoint, CheckpointDecision) - Normalize(laneID string, moduleKey string, dependencies []CheckpointFingerprint) (NormalizeCheckpoint, CheckpointDecision) - AcceptedNormalize(stepID, laneID, moduleKey string) (NormalizeCheckpoint, CheckpointDecision) -} - -// StepCheckpointLoader is the step-aware counterpart used by the persistent -// checkpoint implementation. Loaders without this optional interface remain -// usable by framework callers and test doubles through the legacy methods. -type StepCheckpointLoader interface { - ExtractForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) - MergeForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint) (MergeCheckpoint, CheckpointDecision) - NormalizeForStep(stepID, laneID string, moduleKey string, dependencies []CheckpointFingerprint) (NormalizeCheckpoint, CheckpointDecision) -} - -type noopCheckpointRecorder struct{} -type noopCheckpointLoader struct{} - -func NoopCheckpointRecorder() CheckpointRecorder { return noopCheckpointRecorder{} } -func NoopCheckpointLoader() CheckpointLoader { return noopCheckpointLoader{} } - -func (noopCheckpointRecorder) SourceRunning(string) error { return nil } -func (noopCheckpointRecorder) SourceSucceeded(string, *source.SourceDocument) error { return nil } -func (noopCheckpointRecorder) SourceFailed(string, error) error { return nil } -func (noopCheckpointRecorder) ExtractRunning(string, string, []CheckpointFingerprint) error { - return nil -} -func (noopCheckpointRecorder) ExtractSucceeded(string, string, []CheckpointFingerprint, []CheckpointArtifact, []contracts.RejectedOutput) error { - return nil -} -func (noopCheckpointRecorder) ExtractFailed(string, string, []CheckpointFingerprint, error) error { - return nil -} -func (noopCheckpointRecorder) MergeRunning(string, string, []CheckpointFingerprint) error { return nil } -func (noopCheckpointRecorder) MergeSucceeded(string, string, []CheckpointFingerprint, CheckpointArtifact) error { - return nil -} -func (noopCheckpointRecorder) MergeRejected(string, string, []CheckpointFingerprint, contracts.RejectedOutput) error { - return nil -} -func (noopCheckpointRecorder) MergeFailed(string, string, []CheckpointFingerprint, error) error { - return nil -} -func (noopCheckpointRecorder) NormalizeRunning(string, string, []CheckpointFingerprint) error { - return nil -} -func (noopCheckpointRecorder) NormalizeSucceeded(string, string, []CheckpointFingerprint, CheckpointArtifact) error { - return nil -} -func (noopCheckpointRecorder) NormalizeRejected(string, string, []CheckpointFingerprint, contracts.RejectedOutput) error { - return nil -} -func (noopCheckpointRecorder) NormalizeFailed(string, string, []CheckpointFingerprint, error) error { - return nil -} - -func (noopCheckpointLoader) Enabled() bool { return false } -func (noopCheckpointLoader) Source(string) (SourceCheckpoint, CheckpointDecision) { - return SourceCheckpoint{}, checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonLoadingDisabled) -} -func (noopCheckpointLoader) Extract(string, string, []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) { - return ExtractCheckpoint{}, checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonLoadingDisabled) -} -func (noopCheckpointLoader) Merge(string, string, []CheckpointFingerprint) (MergeCheckpoint, CheckpointDecision) { - return MergeCheckpoint{}, checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonLoadingDisabled) -} -func (noopCheckpointLoader) Normalize(string, string, []CheckpointFingerprint) (NormalizeCheckpoint, CheckpointDecision) { - return NormalizeCheckpoint{}, checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonLoadingDisabled) -} -func (noopCheckpointLoader) AcceptedNormalize(string, string, string) (NormalizeCheckpoint, CheckpointDecision) { - return NormalizeCheckpoint{}, checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonLoadingDisabled) -} - -func checkpointExtractRunning(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.ExtractRunningForStep(stepID, laneID, moduleKey, deps) - } - return recorder.ExtractRunning(laneID, moduleKey, deps) -} -func checkpointExtractSucceeded(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, outputs []CheckpointArtifact, rejected []contracts.RejectedOutput) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.ExtractSucceededForStep(stepID, laneID, moduleKey, deps, outputs, rejected) - } - return recorder.ExtractSucceeded(laneID, moduleKey, deps, outputs, rejected) -} -func checkpointExtractFailed(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, err error) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.ExtractFailedForStep(stepID, laneID, moduleKey, deps, err) - } - return recorder.ExtractFailed(laneID, moduleKey, deps, err) -} -func checkpointMergeRunning(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.MergeRunningForStep(stepID, laneID, moduleKey, deps) - } - return recorder.MergeRunning(laneID, moduleKey, deps) -} -func checkpointMergeSucceeded(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.MergeSucceededForStep(stepID, laneID, moduleKey, deps, output) - } - return recorder.MergeSucceeded(laneID, moduleKey, deps, output) -} -func checkpointMergeRejected(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, rejected contracts.RejectedOutput) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.MergeRejectedForStep(stepID, laneID, moduleKey, deps, rejected) - } - return recorder.MergeRejected(laneID, moduleKey, deps, rejected) -} -func checkpointMergeFailed(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, err error) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.MergeFailedForStep(stepID, laneID, moduleKey, deps, err) - } - return recorder.MergeFailed(laneID, moduleKey, deps, err) -} -func checkpointNormalizeRunning(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.NormalizeRunningForStep(stepID, laneID, moduleKey, deps) - } - return recorder.NormalizeRunning(laneID, moduleKey, deps) -} -func checkpointNormalizeSucceeded(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.NormalizeSucceededForStep(stepID, laneID, moduleKey, deps, output) - } - return recorder.NormalizeSucceeded(laneID, moduleKey, deps, output) -} -func checkpointNormalizeRejected(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, rejected contracts.RejectedOutput) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.NormalizeRejectedForStep(stepID, laneID, moduleKey, deps, rejected) - } - return recorder.NormalizeRejected(laneID, moduleKey, deps, rejected) -} -func checkpointNormalizeFailed(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, err error) error { - if stepAware, ok := recorder.(StepCheckpointRecorder); ok { - return stepAware.NormalizeFailedForStep(stepID, laneID, moduleKey, deps, err) - } - return recorder.NormalizeFailed(laneID, moduleKey, deps, err) -} - -func digestFingerprints(name string, digest string) []CheckpointFingerprint { - digest = strings.TrimSpace(digest) - if digest == "" { - return nil - } - return []CheckpointFingerprint{{Name: name, Value: digest}} -} - -func joinedChunkDigest(chunks []source.Chunk) (string, error) { - if len(chunks) == 0 { - return "", nil - } - values := make([]string, 0, len(chunks)) - for _, chunk := range chunks { - digest, err := source.DigestChunk(chunk) - if err != nil { - return "", fmt.Errorf("digest chunk %q: %w", chunk.ID, err) - } - values = append(values, chunk.ID+"="+digest) - } - sort.Strings(values) - sum := sha256.Sum256([]byte(strings.Join(values, "\n"))) - return "sha256:" + hex.EncodeToString(sum[:]), nil -} - -func normalizeCheckpointFingerprints(values []CheckpointFingerprint) []CheckpointFingerprint { - if len(values) == 0 { - return nil - } - byName := make(map[string]string, len(values)) - for _, value := range values { - name := strings.TrimSpace(value.Name) - fingerprint := strings.TrimSpace(value.Value) - if name == "" || fingerprint == "" { - continue - } - byName[name] = fingerprint - } - if len(byName) == 0 { - return nil - } - names := make([]string, 0, len(byName)) - for name := range byName { - names = append(names, name) - } - sort.Strings(names) - out := make([]CheckpointFingerprint, 0, len(names)) - for _, name := range names { - out = append(out, CheckpointFingerprint{Name: name, Value: byName[name]}) - } - return out -} - -func checkpointContentDigest(content []byte) string { - sum := sha256.Sum256(content) - return "sha256:" + hex.EncodeToString(sum[:]) -} diff --git a/internal/framework/pipeline/chunk_cache.go b/internal/framework/pipeline/chunk_cache.go deleted file mode 100644 index ff0b8dca..00000000 --- a/internal/framework/pipeline/chunk_cache.go +++ /dev/null @@ -1,29 +0,0 @@ -package pipeline - -import ( - "fmt" - "strings" -) - -type ChunkCacheMode string - -const ( - ChunkCacheAuto ChunkCacheMode = "auto" - ChunkCacheBypass ChunkCacheMode = "bypass" - ChunkCacheRefresh ChunkCacheMode = "refresh" -) - -func ParseChunkCacheMode(raw string) (ChunkCacheMode, error) { - mode := ChunkCacheMode(strings.TrimSpace(raw)) - switch mode { - case ChunkCacheAuto, ChunkCacheBypass, ChunkCacheRefresh: - return mode, nil - default: - return "", fmt.Errorf("chunk cache mode %q is not supported", strings.TrimSpace(raw)) - } -} - -func (m ChunkCacheMode) Validate() error { - _, err := ParseChunkCacheMode(string(m)) - return err -} diff --git a/internal/framework/pipeline/chunk_cache_test.go b/internal/framework/pipeline/chunk_cache_test.go deleted file mode 100644 index 11334e6d..00000000 --- a/internal/framework/pipeline/chunk_cache_test.go +++ /dev/null @@ -1,20 +0,0 @@ -package pipeline - -import "testing" - -func TestParseChunkCacheMode(t *testing.T) { - for _, value := range []ChunkCacheMode{ChunkCacheAuto, ChunkCacheBypass, ChunkCacheRefresh} { - got, err := ParseChunkCacheMode(string(value)) - if err != nil || got != value { - t.Fatalf("ParseChunkCacheMode(%q) = %q, %v", value, got, err) - } - if err := value.Validate(); err != nil { - t.Fatalf("%q.Validate() error = %v", value, err) - } - } - for _, value := range []string{"", "enabled", "AUTO", "auto,refresh"} { - if _, err := ParseChunkCacheMode(value); err == nil { - t.Fatalf("ParseChunkCacheMode(%q) error = nil, want error", value) - } - } -} diff --git a/internal/framework/pipeline/chunk_plan_cache_test.go b/internal/framework/pipeline/chunk_plan_cache_test.go new file mode 100644 index 00000000..2bf4334a --- /dev/null +++ b/internal/framework/pipeline/chunk_plan_cache_test.go @@ -0,0 +1,425 @@ +package pipeline + +import ( + "context" + "encoding/json" + "fmt" + "os" + "path/filepath" + "reflect" + "strings" + "testing" + + "gitea.maximumdirect.net/eric/notarius/internal/core/source" + "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" + "go.maximumdirect.net/configkit" + "go.maximumdirect.net/promptkit" +) + +// This producer uses real native preparation/continuation and returns domain +// plans; only the provider is faked by the tests. +type cachedPlanChunker struct{ engine *promptkit.Engine } + +func (cachedPlanChunker) Key() string { return "cached-plan" } +func (cachedPlanChunker) ReferenceSlots() []contracts.ReferenceSlot { return nil } +func (c cachedPlanChunker) Plan(ctx context.Context, request contracts.ChunkRequest) (contracts.ChunkPlanResult, error) { + references := map[string][]string{} + for name, slot := range request.References.Slots { + for _, item := range slot.Items { + references[name] = append(references[name], string(item.Content)) + } + } + referenceContent, err := json.Marshal(references) + if err != nil { + return contracts.ChunkPlanResult{}, err + } + initial := nativeProducerInitial() + initial.ProfileID, initial.SessionID = request.LLMProfile, request.SessionID + initial.Inputs["source"] = promptkit.Inline(string(request.SourceInput.Content) + "\n" + string(referenceContent)) + plan, outcome, err := RunProducer(ctx, c.engine, request.Operation, initial, + func(_ context.Context, result *promptkit.RunResult) (*source.ChunkPlan, []string, error) { + var plan source.ChunkPlan + err := json.Unmarshal([]byte(result.RawOutput), &plan) + return &plan, nil, err + }, producerCorrection, func(context.Context, *source.ChunkPlan) (source.ChunkPlan, error) { + return source.ChunkPlan{SourceDigest: request.Source.Digest, Ranges: []source.ChunkRange{{StartUnitID: request.Source.Units[0].ID, EndUnitID: request.Source.Units[len(request.Source.Units)-1].ID}}}, nil + }) + return contracts.ChunkPlanResult{Plan: plan, Outcome: outcome}, err +} + +func planCacheRunInput(t *testing.T, engine *promptkit.Engine, validator chunkAssessmentValidator) RunInput { + t.Helper() + catalog := typedResolutionCatalog(t, completeTypedCatalogOptions()) + if err := catalog.Chunkers.RegisterBuilderWithSpec(ModuleSpec{Key: "cached-plan", Stage: StageChunk, ExecutionClass: contracts.ExecutionClassLLMBacked}, rejectUnconfiguredOptions, func(request BuildRequest) (contracts.Chunker, error) { + return cachedPlanChunker{request.Dependencies.Engine}, nil + }); err != nil { + t.Fatal(err) + } + if err := RegisterChunkValidator(catalog.Validators, ValidatorSpec{Key: "plan-policy", ExecutionClass: contracts.ExecutionClassDeterministic}, func() (contracts.ChunkValidator, error) { + return namedPlanValidator{"plan-policy", validator}, nil + }); err != nil { + t.Fatal(err) + } + profile := typedResolutionProfile() + profile.Chunk = Binding("cached-plan") + profile.Chunk.Validators = ValidatorOverride{Set: true, Validators: []ModuleBinding{Binding("plan-policy")}} + prepared := prepareRunnerProfile(t, catalog, profile, engine) + return RunInput{Prepared: prepared, pipeline: prepared.resolved} +} + +func planCacheSource(doc *source.SourceDocument) contracts.LLMInputMaterial { + var texts []string + for _, unit := range doc.Units { + texts = append(texts, unit.Text) + } + return contracts.NewLLMInputMaterial("source", "text/plain", []byte(strings.Join(texts, "\n")), "", "") +} + +func planResponse(t *testing.T, plan source.ChunkPlan) *promptkit.GenerateResponse { + t.Helper() + content, err := json.Marshal(plan) + if err != nil { + t.Fatal(err) + } + return &promptkit.GenerateResponse{Content: string(content)} +} + +func TestChunkPlanCacheStoresFinalPlanAndReusesWithoutAssessment(t *testing.T) { + root, store := filesystemProducerCache(t) + doc := typedTestDocumentWithUnits(2) + whole := source.ChunkPlan{SourceDigest: doc.Digest, Ranges: []source.ChunkRange{{StartUnitID: 1, EndUnitID: 2}}} + final := typedTestPlan(doc) + calls, assessments := 0, 0 + client := producerClientFunc(func(_ context.Context, request promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { + calls++ + if calls == 1 { + return planResponse(t, whole), nil + } + if calls == 2 { + if len(request.Prompt.Messages) != 4 { + t.Fatalf("correction history=%#v", request.Prompt.Messages) + } + } + return planResponse(t, final), nil + }) + engine := nativeProducerEngine(t, client) + input := planCacheRunInput(t, engine, func(_ context.Context, request contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { + assessments++ + if len(request.Chunks) == 1 { + return contracts.ValidationResult{ReasonCode: "partition", CorrectionGuidance: "Use separate scenes."}, nil + } + return contracts.ValidationResult{Approved: true}, nil + }) + input.Cache = store + var keys, decisions []string + input.ObserveCache = func(_ context.Context, origin contracts.DiagnosticOrigin, observation contracts.CacheObservation) error { + if origin.Stage != contracts.DiagnosticOriginStageChunk || origin.ModuleKey != "cached-plan" { + t.Fatalf("cache scope=%#v", origin) + } + if observation.Prepared != nil { + keys = append(keys, observation.MessageContentHash) + } + decisions = append(decisions, observation.Decision) + return nil + } + store.beforeWrite = func(_ string, _ []byte) { + if calls != 2 || assessments != 2 { + t.Fatal("plan stored before correction acceptance") + } + } + first, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "first-session") + if err != nil || !first.accepted || len(first.chunks) != 2 || calls != 2 || assessments != 2 || store.writes != 1 { + t.Fatalf("first plan=%#v err=%v calls=%d assessments=%d", first, err, calls, assessments) + } + bytes, err := os.ReadFile(filepath.Join(root, keys[0]+".json")) + var saved source.ChunkPlan + if err != nil || json.Unmarshal(bytes, &saved) != nil || !reflect.DeepEqual(saved, *first.plan) { + t.Fatalf("cache is not the final raw plan: %s %v", bytes, err) + } + var fields map[string]json.RawMessage + if err := json.Unmarshal(bytes, &fields); err != nil { + t.Fatal(err) + } + for _, field := range []string{"producer", "checkpoint", "document", "provenance", "usage"} { + if _, ok := fields[field]; ok { + t.Fatalf("cache contains reporting field %q", field) + } + } + store.beforeWrite = nil + input.pipeline.Chunk.LLMProfile = "chosen" + input.Execution.Execution = &promptkit.ExecutionTargetOverride{Model: "another-model"} + second, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "changed-session") + if err != nil || !second.outcome.ReuseEligible || len(second.chunks) != 2 || calls != 2 || assessments != 2 || len(keys) != 2 || keys[0] != keys[1] { + t.Fatalf("settings-only reuse=%#v %v calls=%d assessments=%d keys=%v", second, err, calls, assessments, keys) + } + if !reflect.DeepEqual(decisions, []string{"prepared", "miss", "stored", "prepared", "hit"}) { + t.Fatalf("cache decisions=%v", decisions) + } + // Materialization is against the current source, not cached transcript bytes. + changed := *doc + changed.ID = "current-source" + changed.Units = append([]source.SourceUnit(nil), doc.Units...) + for i := range changed.Units { + changed.Units[i].Ref.SourceID = changed.ID + } + changed.Digest, _ = source.DigestDocument(&changed) + // Identity is part of ordinary plan usability if it changes the source digest. + // Supplying the matching digest lets this check focus on rematerialized refs. + saved.SourceDigest = changed.Digest + replacement, _ := json.Marshal(saved) + if err := store.inner.Store(context.Background(), contracts.CacheRefresh, keys[0], replacement); err != nil { + t.Fatal(err) + } + third, err := New().runChunkPlan(context.Background(), input, &changed, planCacheSource(doc), "session") + if err != nil || calls != 2 || assessments != 2 || third.chunks[0].Ref.SourceID != changed.ID || third.chunks[0].Units[0].Ref.SourceID != changed.ID { + t.Fatalf("rematerialization=%#v %v", third, err) + } +} + +func TestChunkPlanCacheUsesMessageContentRatherThanSourceIdentity(t *testing.T) { + _, store := filesystemProducerCache(t) + doc := typedTestDocumentWithUnits(2) + calls, assessments := 0, 0 + client := producerClientFunc(func(context.Context, promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { + calls++ + plan := typedTestPlan(doc) + if calls > 1 { + plan.Ranges = []source.ChunkRange{{StartUnitID: 1, EndUnitID: 2}} + } + return planResponse(t, plan), nil + }) + validator := chunkAssessmentValidator(func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { + assessments++ + return contracts.ValidationResult{Approved: true}, nil + }) + input := planCacheRunInput(t, nativeProducerEngine(t, client), validator) + input.Cache = store + var keys []string + input.ObserveCache = func(_ context.Context, _ contracts.DiagnosticOrigin, observation contracts.CacheObservation) error { + if observation.Prepared != nil { + keys = append(keys, observation.MessageContentHash) + } + return nil + } + run := func(wantChunks int) { + t.Helper() + result, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "session") + if err != nil || len(result.chunks) != wantChunks { + t.Fatalf("chunks=%d err=%v", len(result.chunks), err) + } + } + run(2) + input.pipeline.ChunkReferences.ReferenceSet = contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{"context": {Items: []contracts.ReferenceItem{{Content: []byte("new scene context")}}}}} + run(1) + // Replace only the prompt text, retaining source and reference bytes. + input.Prepared.chunker = cachedPlanChunker{nativeProducerEngine(t, client, promptkit.SettingsInput(configkit.Bytes("changed prompt", []byte(`prompts: + - id: initial + default_profile: base + inputs: [{name: source, required: true}] + messages: + - {role: system, content: 'A changed scene assignment.'} + - {role: user, content: 'Source: {{input "source"}}'} + output: {format: json, validation_mode: json, repair_attempts: 0} +`))))} + run(1) + if calls != 3 || assessments != 3 || len(keys) != 3 || keys[0] == keys[1] || keys[1] == keys[2] { + t.Fatalf("content reuse: calls=%d assessments=%d keys=%v", calls, assessments, keys) + } +} + +func TestChunkPlanCacheUnusableEntriesAreMissesNotAssistantCandidates(t *testing.T) { + for _, defect := range []string{"source digest", "source range", "malformed", "legacy envelope"} { + t.Run(defect, func(t *testing.T) { + root, store := filesystemProducerCache(t) + doc := typedTestDocument() + calls, assessments := 0, 0 + engine := nativeProducerEngine(t, producerClientFunc(func(_ context.Context, request promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { + calls++ + if len(request.Prompt.Messages) != 2 { + t.Fatal("unusable cache replayed as an assistant candidate") + } + return planResponse(t, typedTestPlan(doc)), nil + })) + input := planCacheRunInput(t, engine, func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { + assessments++ + return contracts.ValidationResult{Approved: true}, nil + }) + input.Cache = store + var key string + input.ObserveCache = func(_ context.Context, _ contracts.DiagnosticOrigin, observation contracts.CacheObservation) error { + if observation.Prepared != nil { + key = observation.MessageContentHash + } + return nil + } + if _, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "session"); err != nil { + t.Fatal(err) + } + bad := typedTestPlan(doc) + switch defect { + case "source digest": + bad.SourceDigest = "not-current" + case "source range": + bad.Ranges[0].EndUnitID = 999 + } + content, _ := json.Marshal(bad) + if defect == "malformed" { + content = []byte("{") + } + if defect == "legacy envelope" { + content = []byte(`{"plan":{},"producer":{"key":"legacy"}}`) + } + // Simulate an existing corrupt entry without going through valid writes. + if err := os.WriteFile(filepath.Join(root, key+".json"), content, 0644); err != nil { + t.Fatal(err) + } + result, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "session") + if err != nil || !result.accepted || calls != 2 || assessments != 2 || len(result.diagnostics) != 1 { + t.Fatalf("unusable plan=%#v err=%v calls=%d assessments=%d", result, err, calls, assessments) + } + }) + } +} + +func TestChunkPlanCacheModesAndTerminalExclusions(t *testing.T) { + for _, test := range []struct { + name string + cache contracts.CacheMode + mode contracts.ExecutionMode + reject, ineligible bool + reads, writes int + fallback bool + }{ + {"auto", contracts.CacheAuto, contracts.ModeStrict, false, false, 1, 1, false}, + {"bypass", contracts.CacheBypass, contracts.ModeStrict, false, false, 0, 0, false}, + {"refresh", contracts.CacheRefresh, contracts.ModeStrict, false, false, 0, 1, false}, + {"ineligible", contracts.CacheAuto, contracts.ModeStrict, false, true, 0, 0, false}, + {"strict rejection", contracts.CacheAuto, contracts.ModeStrict, true, false, 1, 0, false}, + {"permissive fallback", contracts.CacheAuto, contracts.ModePermissive, true, false, 1, 0, true}, + } { + t.Run(test.name, func(t *testing.T) { + _, store := filesystemProducerCache(t) + doc := typedTestDocumentWithUnits(2) + calls, assessments := 0, 0 + engine := nativeProducerEngine(t, producerClientFunc(func(context.Context, promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { + calls++ + return planResponse(t, typedTestPlan(doc)), nil + })) + input := planCacheRunInput(t, engine, func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { + assessments++ + return contracts.ValidationResult{Approved: !test.reject, ReasonCode: "policy", CorrectionGuidance: "Revise the scene partition."}, nil + }) + input.Cache = store + input.reuseIneligible = test.ineligible + input.pipeline.ChunkControls = contracts.ProducerControls{Cache: test.cache, Mode: test.mode, MaxAdditionalTurns: 0} + result, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "session") + if (err != nil) != (test.reject && !test.fallback) || calls != 1 || assessments != 1 || store.reads != test.reads || store.writes != test.writes { + t.Fatalf("result=%#v err=%v calls=%d assessments=%d cache=%d/%d", result, err, calls, assessments, store.reads, store.writes) + } + if test.fallback && (result.outcome.Disposition != contracts.ProducerFallback || result.outcome.ReuseEligible || len(result.chunks) != 1 || len(result.chunks[0].Units) != 2) { + t.Fatalf("invalid whole-source fallback: %#v", result) + } + }) + } +} + +func TestChunkPlanFailedRefreshPreservesAcceptanceAndIgnoresLegacyRecords(t *testing.T) { + root, store := filesystemProducerCache(t) + legacyNames := []string{"checkpoints/run/manifest.json", "chunk-plans/source/plan.json"} + for _, name := range legacyNames { + filename := filepath.Join(root, name) + if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filename, []byte("unread legacy bytes"), 0644); err != nil { + t.Fatal(err) + } + } + doc := typedTestDocumentWithUnits(2) + reject := false + calls, assessments := 0, 0 + engine := nativeProducerEngine(t, producerClientFunc(func(context.Context, promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { + calls++ + return planResponse(t, typedTestPlan(doc)), nil + })) + input := planCacheRunInput(t, engine, func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { + assessments++ + return contracts.ValidationResult{Approved: !reject, ReasonCode: "partition", CorrectionGuidance: "Reconsider the partition."}, nil + }) + input.Cache = store + input.pipeline.ChunkControls.MaxAdditionalTurns = 0 + var key string + input.ObserveCache = func(_ context.Context, _ contracts.DiagnosticOrigin, observation contracts.CacheObservation) error { + if observation.Prepared != nil { + key = observation.MessageContentHash + } + return nil + } + if _, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "session"); err != nil { + t.Fatal(err) + } + original, err := os.ReadFile(filepath.Join(root, key+".json")) + if err != nil { + t.Fatal(err) + } + reject = true + input.pipeline.ChunkControls.Cache = contracts.CacheRefresh + for _, mode := range []contracts.ExecutionMode{contracts.ModeStrict, contracts.ModePermissive} { + input.pipeline.ChunkControls.Mode = mode + result, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "session") + if (err != nil) != (mode == contracts.ModeStrict) { + t.Fatalf("refresh mode=%s result=%#v error=%v", mode, result, err) + } + if mode == contracts.ModePermissive && (result.outcome.ReuseEligible || result.outcome.Disposition != contracts.ProducerFallback) { + t.Fatalf("fallback=%#v", result.outcome) + } + current, err := os.ReadFile(filepath.Join(root, key+".json")) + if err != nil || string(current) != string(original) { + t.Fatal("failed refresh changed old acceptance") + } + } + input.pipeline.ChunkControls.Cache = contracts.CacheAuto + result, err := New().runChunkPlan(context.Background(), input, doc, planCacheSource(doc), "session") + if err != nil || result.outcome.Disposition != contracts.ProducerAccepted || calls != 3 || assessments != 3 || store.reads != 2 || store.writes != 1 { + t.Fatalf("old acceptance not reused: %#v %v calls=%d assessments=%d cache=%d/%d", result, err, calls, assessments, store.reads, store.writes) + } + for _, name := range legacyNames { + content, err := os.ReadFile(filepath.Join(root, name)) + if err != nil || string(content) != "unread legacy bytes" { + t.Fatalf("legacy record modified: %s %q %v", name, content, err) + } + } +} + +func TestDeterministicChunkingIgnoresCacheAndLegacyRecords(t *testing.T) { + root, store := filesystemProducerCache(t) + legacy := map[string][]byte{"checkpoints/identity/manifest.json": []byte("old checkpoint"), "chunk-plans/source.json": []byte("old plan")} + for name, content := range legacy { + filename := filepath.Join(root, name) + if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filename, content, 0644); err != nil { + t.Fatal(err) + } + } + catalog := typedResolutionCatalog(t, completeTypedCatalogOptions()) + prepared := prepareRunnerProfile(t, catalog, typedResolutionProfile(), nil) + input := RunInput{Prepared: prepared, RawInput: []byte("input"), Cache: store, ObserveCache: func(context.Context, contracts.DiagnosticOrigin, contracts.CacheObservation) error { + return fmt.Errorf("deterministic chunker prepared a synthetic request") + }} + for range 2 { + if _, err := New().Run(context.Background(), input); err != nil { + t.Fatal(err) + } + } + if store.reads != 0 || store.writes != 0 { + t.Fatalf("deterministic cache I/O=%d/%d", store.reads, store.writes) + } + for name, want := range legacy { + got, err := os.ReadFile(filepath.Join(root, name)) + if err != nil || string(got) != string(want) { + t.Fatalf("legacy record modified: %s %q %v", name, got, err) + } + } +} diff --git a/internal/framework/pipeline/chunk_plan_store.go b/internal/framework/pipeline/chunk_plan_store.go deleted file mode 100644 index a9147964..00000000 --- a/internal/framework/pipeline/chunk_plan_store.go +++ /dev/null @@ -1,49 +0,0 @@ -package pipeline - -import ( - "time" - - "gitea.maximumdirect.net/eric/notarius/internal/core/artifacts" - "gitea.maximumdirect.net/eric/notarius/internal/core/source" - "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" -) - -const ChunkPlanSchemaVersion = "notarius.chunk-plan.v3" - -type ChunkPlanProducer struct { - InputModule string `json:"input_module"` - ChunkModule string `json:"chunk_module"` - LLMProfile string `json:"llm_profile,omitempty"` - References []artifacts.ReferenceProvenance `json:"references,omitempty"` - Metadata map[string]any `json:"metadata,omitempty"` -} - -type ChunkPlanRecord struct { - SchemaVersion string `json:"schema_version"` - SourceDigest string `json:"source_digest"` - PlanDigest string `json:"plan_digest"` - Plan source.ChunkPlan `json:"plan"` - Producer ChunkPlanProducer `json:"producer"` - Diagnostics []contracts.ProducerDiagnostic `json:"diagnostics,omitempty"` - CreatedAt time.Time `json:"created_at"` -} - -type ChunkPlanStore interface { - Load(sourceDigest string) (ChunkPlanRecord, ChunkPlanDecision, error) - Save(ChunkPlanRecord) error -} - -type ChunkPlanStoreFactory func(root string) (ChunkPlanStore, error) - -type ChunkPlanDecision struct { - Status ChunkPlanStatus `json:"status"` - Reason string `json:"reason,omitempty"` -} - -type ChunkPlanStatus string - -const ( - ChunkPlanHit ChunkPlanStatus = "hit" - ChunkPlanMissing ChunkPlanStatus = "missing" - ChunkPlanInvalid ChunkPlanStatus = "invalid" -) diff --git a/internal/framework/pipeline/diagnostics.go b/internal/framework/pipeline/diagnostics.go index 7fb5d889..03564250 100644 --- a/internal/framework/pipeline/diagnostics.go +++ b/internal/framework/pipeline/diagnostics.go @@ -1,41 +1,11 @@ package pipeline import ( - "fmt" - "gitea.maximumdirect.net/eric/notarius/internal/core/source" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" frameworkdiagnostics "gitea.maximumdirect.net/eric/notarius/internal/framework/diagnostics" ) -func promoteCheckpointDiagnostics(diagnostics []CheckpointDiagnostic, origin contracts.DiagnosticOrigin, chunk *source.Chunk) ([]contracts.DiagnosticGroup, error) { - groups := make([]contracts.DiagnosticGroup, 0, len(diagnostics)) - for _, record := range diagnostics { - validatorOrigin := origin - validatorOrigin.ValidatorKey = record.ValidatorKey - promoted, err := promoteProducerDiagnostics([]contracts.ProducerDiagnostic{record.Diagnostic}, validatorOrigin, chunk) - if err != nil { - return nil, fmt.Errorf("checkpoint diagnostic: %w", err) - } - groups = append(groups, promoted...) - } - return groups, nil -} - -func cloneCheckpointDiagnostics(diagnostics []CheckpointDiagnostic) []CheckpointDiagnostic { - if len(diagnostics) == 0 { - return nil - } - cloned := make([]CheckpointDiagnostic, len(diagnostics)) - for index, diagnostic := range diagnostics { - cloned[index] = CheckpointDiagnostic{ - Diagnostic: contracts.CloneProducerDiagnostics([]contracts.ProducerDiagnostic{diagnostic.Diagnostic})[0], - ValidatorKey: diagnostic.ValidatorKey, - } - } - return cloned -} - func promoteProducerDiagnostics(diagnostics []contracts.ProducerDiagnostic, origin contracts.DiagnosticOrigin, chunk *source.Chunk) ([]contracts.DiagnosticGroup, error) { if err := contracts.ValidateProducerDiagnostics(diagnostics); err != nil { return nil, err diff --git a/internal/framework/pipeline/evidence_output.go b/internal/framework/pipeline/evidence_output.go index 3713f8eb..56518970 100644 --- a/internal/framework/pipeline/evidence_output.go +++ b/internal/framework/pipeline/evidence_output.go @@ -26,7 +26,7 @@ type debugEvidenceContextSummary struct { // buildOutputEvidenceContext projects the prepared output policy from accepted // normalized artifacts. It is intentionally separate from lane execution so -// checkpointed normalized outputs use the same reconstruction path. +// cached normalized outputs use the same reconstruction path. func buildOutputEvidenceContext(prepared *PreparedPipeline, doc *source.SourceDocument, outputs []contracts.SerializedOutput) (*contracts.SerializedArtifact, *debugEvidenceContextSummary, error) { if prepared == nil || prepared.evidencePlan == nil { return nil, nil, nil diff --git a/internal/framework/pipeline/handoff.go b/internal/framework/pipeline/handoff.go index f0d8a1b6..f7ef7ac7 100644 --- a/internal/framework/pipeline/handoff.go +++ b/internal/framework/pipeline/handoff.go @@ -1,9 +1,6 @@ package pipeline import ( - "crypto/sha256" - "encoding/hex" - "encoding/json" "fmt" "sort" "strings" @@ -301,60 +298,3 @@ func referenceProvenanceForItem(target ResolvedReferenceTarget, item contracts.R ProducerModule: item.Producer.ModuleKey, } } - -type generatedReferenceFingerprintIdentity struct { - ProducerPipeline string `json:"producer_pipeline_id"` - ProducerStep string `json:"producer_step_id"` - ProducerLane string `json:"producer_lane_id"` - ProducerModule string `json:"producer_module_key"` - ArtifactKind string `json:"artifact_kind"` - SchemaID string `json:"schema_id"` - SchemaName string `json:"schema_name"` - SchemaVersion string `json:"schema_version"` - SchemaDigest string `json:"schema_digest"` - MediaType string `json:"media_type"` - ContentDigest string `json:"content_digest"` - SizeBytes int64 `json:"size_bytes"` -} - -// generatedReferenceDependencies returns the canonical semantic dependency -// identity that receiving operation checkpoints must include. -func generatedReferenceDependencies(set contracts.ReferenceSet) []CheckpointFingerprint { - var fingerprints []CheckpointFingerprint - keys := make([]string, 0, len(set.Slots)) - for key := range set.Slots { - keys = append(keys, key) - } - sort.Strings(keys) - for _, slotName := range keys { - for index, item := range set.Slots[slotName].Items { - if item.Origin.Type != "generated" { - continue - } - identity := generatedReferenceFingerprintIdentity{ - ProducerPipeline: item.Producer.PipelineID, - ProducerStep: item.Producer.StepID, - ProducerLane: item.Producer.LaneID, - ProducerModule: item.Producer.ModuleKey, - ArtifactKind: string(item.ArtifactKind), - SchemaID: item.ArtifactSchema.ID, - SchemaName: item.ArtifactSchema.Name, - SchemaVersion: item.ArtifactSchema.Version, - SchemaDigest: contracts.DigestArtifactSchema(item.ArtifactSchema), - MediaType: item.MediaType, - ContentDigest: item.Digest, - SizeBytes: item.SizeBytes, - } - encoded, err := json.Marshal(identity) - if err != nil { - continue - } - sum := sha256.Sum256(encoded) - fingerprints = append(fingerprints, CheckpointFingerprint{ - Name: fmt.Sprintf("generated-reference:%s:%d", slotName, index), - Value: "sha256:" + hex.EncodeToString(sum[:]), - }) - } - } - return normalizeCheckpointFingerprints(fingerprints) -} diff --git a/internal/framework/pipeline/prepare.go b/internal/framework/pipeline/prepare.go index b5253d65..db0ebd87 100644 --- a/internal/framework/pipeline/prepare.go +++ b/internal/framework/pipeline/prepare.go @@ -19,15 +19,14 @@ type PreparedPipeline struct { Steps []PreparedPipelineStep Output ModuleBinding - resolved ResolvedPipeline - dependencies ModuleDependencies - input contracts.InputAdapter - chunker contracts.Chunker - chunkValidators preparedValidatorChain - output contracts.OutputEncoder - artifactCodecs *ArtifactCodecRegistry - evidencePlan *preparedEvidencePlan - checkpointFingerprints []CheckpointFingerprint + resolved ResolvedPipeline + dependencies ModuleDependencies + input contracts.InputAdapter + chunker contracts.Chunker + chunkValidators preparedValidatorChain + output contracts.OutputEncoder + artifactCodecs *ArtifactCodecRegistry + evidencePlan *preparedEvidencePlan } type PreparedPipelineStep struct { @@ -158,10 +157,6 @@ func Prepare(resolved ResolvedPipeline, registries Registries, deps ModuleDepend if err != nil { return nil, err } - prepared.checkpointFingerprints, err = collectPreparedCheckpointFingerprints(prepared) - if err != nil { - return nil, err - } return prepared, nil } diff --git a/internal/framework/pipeline/prepared_fingerprints.go b/internal/framework/pipeline/prepared_fingerprints.go deleted file mode 100644 index d63daf34..00000000 --- a/internal/framework/pipeline/prepared_fingerprints.go +++ /dev/null @@ -1,88 +0,0 @@ -package pipeline - -import ( - "fmt" - "sort" - "strings" -) - -type checkpointFingerprintComponent struct { - scope string - module any -} - -// CheckpointFingerprints returns a defensive copy of the stable semantic -// identities contributed by the pipeline's prepared modules and validators. -func (p *PreparedPipeline) CheckpointFingerprints() []CheckpointFingerprint { - if p == nil { - return nil - } - return append([]CheckpointFingerprint(nil), p.checkpointFingerprints...) -} - -func collectPreparedCheckpointFingerprints(prepared *PreparedPipeline) ([]CheckpointFingerprint, error) { - components := []checkpointFingerprintComponent{ - {scope: "input:" + prepared.resolved.Input.Module, module: prepared.input}, - {scope: "chunk:" + prepared.resolved.Chunk.Module, module: prepared.chunker}, - } - components = appendValidatorFingerprintComponents(components, "chunk:"+prepared.resolved.Chunk.Module, prepared.chunkValidators) - for _, step := range prepared.Steps { - for _, lane := range step.lanes { - laneScope := func(stage ModuleStage, moduleKey string) string { - return string(stage) + ":" + lane.resolved.ID + ":" + moduleKey - } - components = append(components, checkpointFingerprintComponent{scope: laneScope(StageExtract, lane.resolved.Extract.Module), module: lane.typed.extractor}) - components = appendValidatorFingerprintComponents(components, laneScope(StageExtract, lane.resolved.Extract.Module), lane.extractValidators) - components = append(components, checkpointFingerprintComponent{scope: laneScope(StageMerge, lane.resolved.Merge.Module), module: lane.typed.merger}) - components = appendValidatorFingerprintComponents(components, laneScope(StageMerge, lane.resolved.Merge.Module), lane.mergeValidators) - components = append(components, checkpointFingerprintComponent{scope: laneScope(StageNormalize, lane.resolved.Normalize.Module), module: lane.typed.normalizer}) - components = appendValidatorFingerprintComponents(components, laneScope(StageNormalize, lane.resolved.Normalize.Module), lane.normalizeValidators) - } - } - components = append(components, checkpointFingerprintComponent{scope: "output:" + prepared.resolved.Output.Module, module: prepared.output}) - - var values []CheckpointFingerprint - seen := make(map[string]struct{}) - for _, item := range components { - provider, ok := item.module.(CheckpointFingerprintProvider) - if !ok { - continue - } - for _, fingerprint := range provider.CheckpointFingerprints() { - name := strings.TrimSpace(fingerprint.Name) - value := strings.TrimSpace(fingerprint.Value) - if name == "" || value == "" { - return nil, fmt.Errorf("pipeline %q checkpoint fingerprint for %s must have a non-empty name and value", prepared.resolved.ID, item.scope) - } - scopedName := item.scope + ":" + name - if _, exists := seen[scopedName]; exists { - return nil, fmt.Errorf("pipeline %q checkpoint fingerprint %q is duplicated", prepared.resolved.ID, scopedName) - } - seen[scopedName] = struct{}{} - values = append(values, CheckpointFingerprint{Name: scopedName, Value: value}) - } - } - sort.Slice(values, func(i, j int) bool { return values[i].Name < values[j].Name }) - return values, nil -} - -func appendValidatorFingerprintComponents(components []checkpointFingerprintComponent, ownerScope string, chain preparedValidatorChain) []checkpointFingerprintComponent { - for index, validator := range chain.validators { - scope := fmt.Sprintf("%s:validator:%d:%s", ownerScope, index, validator.resolved.Binding.Module) - components = append(components, checkpointFingerprintComponent{scope: scope, module: preparedValidatorImplementation(validator)}) - } - return components -} - -func preparedValidatorImplementation(validator preparedValidator) any { - switch validator.resolved.Target { - case ValidatorTargetTyped: - return validator.typed - case ValidatorTargetChunk: - return validator.chunk - case ValidatorTargetSerialized: - return validator.serialized - default: - return nil - } -} diff --git a/internal/framework/pipeline/runner.go b/internal/framework/pipeline/runner.go index 89bd9030..63aca3ca 100644 --- a/internal/framework/pipeline/runner.go +++ b/internal/framework/pipeline/runner.go @@ -44,24 +44,20 @@ type RunInput struct { Cache contracts.ArtifactCache // ObserveCache receives scoped transient evidence, including prepared details // on a hit. Shared observers must synchronize concurrent calls. - ObserveCache func(context.Context, contracts.DiagnosticOrigin, contracts.CacheObservation) error - Execution contracts.ExecutionOptions - Prepared *PreparedPipeline - SourceID string - Path string - RawInput []byte - SessionID string - RunID string - StartedAt time.Time - LLMProfiles []artifacts.LLMProfileManifest - Metadata map[string]any - Diagnostics []contracts.ProducerDiagnostic - ChunkCacheMode ChunkCacheMode - ChunkPlans ChunkPlanStore - Checkpoints CheckpointRecorder - Checkpoint CheckpointLoader - CheckpointPolicy CheckpointExecutionPolicy - Debug DebugRecorder + ObserveCache func(context.Context, contracts.DiagnosticOrigin, contracts.CacheObservation) error + Execution contracts.ExecutionOptions + Prepared *PreparedPipeline + SourceID string + Path string + RawInput []byte + SessionID string + RunID string + StartedAt time.Time + LLMProfiles []artifacts.LLMProfileManifest + Metadata map[string]any + Diagnostics []contracts.ProducerDiagnostic + + Debug DebugRecorder // Workers bounds ready extraction and lane-completion jobs together. // Zero selects DefaultWorkers; configuration rejects explicit zero. Workers int @@ -75,15 +71,15 @@ type RunInput struct { } type RunOutput struct { - FallbackCount int `json:"fallback_count,omitempty"` - Manifest artifacts.RunManifest `json:"manifest"` - ChunkPlan *artifacts.ChunkPlanSummary `json:"chunk_plan,omitempty"` - NormalizeOutputs []contracts.SerializedOutput `json:"normalize_outputs,omitempty"` - Rejected []contracts.RejectedOutput `json:"rejected,omitempty"` - Diagnostics contracts.DiagnosticCollection `json:"diagnostics,omitempty"` - OutputFiles []contracts.OutputFile `json:"-"` - CheckpointEvents []CheckpointEvent `json:"checkpoint_events,omitempty"` - ValidationSummaries []artifacts.ValidationSummary `json:"validation_summaries,omitempty"` + FallbackCount int `json:"fallback_count,omitempty"` + Manifest artifacts.RunManifest `json:"manifest"` + + NormalizeOutputs []contracts.SerializedOutput `json:"normalize_outputs,omitempty"` + Rejected []contracts.RejectedOutput `json:"rejected,omitempty"` + Diagnostics contracts.DiagnosticCollection `json:"diagnostics,omitempty"` + OutputFiles []contracts.OutputFile `json:"-"` + + ValidationSummaries []artifacts.ValidationSummary `json:"validation_summaries,omitempty"` normalizeReuseEligibility map[generatedOutputKey]bool diagnosticGroups []contracts.DiagnosticGroup @@ -111,25 +107,10 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err if err != nil { return failOutput(output), err } - output.ChunkPlan = &artifacts.ChunkPlanSummary{ - Mode: string(effectiveChunkCacheMode(input.ChunkCacheMode)), RequestedModule: input.pipeline.Chunk.Module, - LookupStatus: "skipped", LookupReason: "chunk plan lookup skipped", - ValidationStatus: "not_run", PublicationStatus: "not_requested", - } - checkpoints := input.Checkpoints - if checkpoints == nil { - checkpoints = NoopCheckpointRecorder() - } - checkpointLoader := input.Checkpoint - if checkpointLoader == nil { - checkpointLoader = NoopCheckpointLoader() - } debugRecorder := input.Debug if debugRecorder == nil { debugRecorder = NoopDebugRecorder() } - checkpoints = synchronizedCheckpointRecorder(checkpoints) - checkpointLoader = synchronizedCheckpointLoader(checkpointLoader) debugRecorder = synchronizedDebugRecorder(debugRecorder) input.Debug = debugRecorder inputDiagnostics, diagnosticErr := promoteProducerDiagnostics(input.Diagnostics, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageReferences}, nil) @@ -153,9 +134,7 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err if err := attachModuleManifestMetadata(&output, "input", adapter); err != nil { return failOutput(output), err } - sourceCheckpoint, sourceDecision := checkpointLoader.Source(adapter.Key()) - recordCheckpointEvent(&output, checkpointLoader, "source", "", "", adapter.Key(), sourceDecision) - doc := sourceCheckpoint.Document + var doc *source.SourceDocument sourceStarted := time.Now().UTC() if err := writeDebugTimed(debugRecorder, "source/input.json", debugTimedEnvelope{ Stage: "source", @@ -171,48 +150,32 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err }); err != nil { return failOutput(output), fmt.Errorf("write source debug artifact: %w", err) } - if !sourceDecision.Reused { - if err := checkpoints.SourceRunning(adapter.Key()); err != nil { - return failOutput(output), fmt.Errorf("write source checkpoint: %w", err) - } - requestMetadata, metadataErr := cloneMetadata(input.Metadata) - if metadataErr != nil { - return failOutput(output), fmt.Errorf("clone input adapter metadata: %w", metadataErr) - } - if err := ctx.Err(); err != nil { - _ = checkpoints.SourceFailed(adapter.Key(), err) - return failOutput(output), err - } - doc, err = adapter.Parse(ctx, contracts.ParseRequest{ - SourceID: input.SourceID, - Path: input.Path, - Raw: input.RawInput, - LLMProfile: input.pipeline.Input.LLMProfile, - Metadata: requestMetadata, - }) - if ctxErr := ctx.Err(); ctxErr != nil { - _ = checkpoints.SourceFailed(adapter.Key(), ctxErr) - return failOutput(output), ctxErr - } - if err != nil { - _ = checkpoints.SourceFailed(adapter.Key(), err) - return failOutput(output), fmt.Errorf("parse input with adapter %q: %w", adapter.Key(), err) - } - if err := source.ValidateDocument(doc); err != nil { - _ = checkpoints.SourceFailed(adapter.Key(), err) - return failOutput(output), fmt.Errorf("validate source document: %w", err) - } - if err := checkpoints.SourceSucceeded(adapter.Key(), doc); err != nil { - return failOutput(output), fmt.Errorf("write source checkpoint: %w", err) - } + requestMetadata, err := cloneMetadata(input.Metadata) + if err != nil { + return failOutput(output), fmt.Errorf("clone input adapter metadata: %w", err) } + if err := ctx.Err(); err != nil { + return failOutput(output), err + } + doc, err = adapter.Parse(ctx, contracts.ParseRequest{ + SourceID: input.SourceID, Path: input.Path, Raw: input.RawInput, + LLMProfile: input.pipeline.Input.LLMProfile, Metadata: requestMetadata, + }) + if ctxErr := ctx.Err(); ctxErr != nil { + return failOutput(output), ctxErr + } + if err != nil { + return failOutput(output), fmt.Errorf("parse input with adapter %q: %w", adapter.Key(), err) + } + if err := source.ValidateDocument(doc); err != nil { + return failOutput(output), fmt.Errorf("validate source document: %w", err) + } + if err := writeDebugTimed(debugRecorder, "source/output.json", debugTimedEnvelope{ Stage: "source", ModuleKey: adapter.Key(), StartedAt: sourceStarted, Payload: map[string]any{ - "reused": sourceDecision.Reused, - "decision": sourceDecision, "document": debugSourceDocumentEnvelope(doc), }, }); err != nil { @@ -226,13 +189,12 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err return failOutput(output), err } chunkStarted := time.Now().UTC() - chunkMode := effectiveChunkCacheMode(input.ChunkCacheMode) if err := writeDebugTimed(debugRecorder, "chunk/input.json", debugTimedEnvelope{ Stage: string(StageChunk), ModuleKey: chunker.Key(), StartedAt: chunkStarted, Payload: map[string]any{ - "cache_mode": chunkMode, + "cache_mode": input.pipeline.ChunkControls.Cache, "source": debugSourceDocumentEnvelope(doc), "source_input": debugContentEnvelope(sourceInput.Content, sourceInput.MediaType, nil, nil), "options": redactSensitiveMap(input.pipeline.Chunk.Options), @@ -242,31 +204,18 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err return failOutput(output), fmt.Errorf("write chunk debug artifact: %w", err) } chunkResult, err := r.runChunkPlan(ctx, input, doc, sourceInput, sessionID) - if applyErr := applyChunkPlanExecution(&output, chunkResult); applyErr != nil { - return failOutput(output), applyErr - } if err != nil { return failOutput(output), err } - if chunkResult.rejection != nil { - output.Rejected = append(output.Rejected, *chunkResult.rejection) - } - if chunkResult.validation != nil { - output.ValidationSummaries = append(output.ValidationSummaries, artifacts.CloneValidationSummary(*chunkResult.validation)) - } appendDiagnosticGroups(&output, chunkResult.diagnostics) chunkDebugPayload := map[string]any{ - "cache_mode": chunkMode, - "lookup": chunkResult.lookup, + "cache_mode": input.pipeline.ChunkControls.Cache, "accepted": chunkResult.accepted, "materialized_chunks": debugSourceChunkEnvelopes(chunkResult.chunks), } if chunkResult.plan != nil { chunkDebugPayload["plan"] = debugChunkPlanEnvelope(*chunkResult.plan) } - if chunkResult.rejection != nil { - chunkDebugPayload["rejection"] = debugRejectedOutputEnvelope(*chunkResult.rejection) - } if err := writeDebugTimed(debugRecorder, "chunk/output.json", debugTimedEnvelope{ Stage: string(StageChunk), ModuleKey: chunker.Key(), @@ -278,8 +227,12 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err var acceptedChunkMap *contracts.SerializedArtifact if chunkResult.accepted { - if chunkResult.plan == nil || chunkResult.record == nil { - return failOutput(output), fmt.Errorf("accepted chunk plan is missing plan or producer record") + if chunkResult.plan == nil { + return failOutput(output), fmt.Errorf("accepted chunk plan is missing") + } + chunkProfile := "" + if input.pipeline.ChunkExecutionClass == contracts.ExecutionClassLLMBacked { + chunkProfile = input.pipeline.Chunk.LLMProfile } artifact, buildErr := chunkmap.Serialize(chunkmap.BuildRequest{ Source: doc, @@ -287,9 +240,9 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err Chunks: chunkResult.chunks, RequestedChunker: input.pipeline.Chunk.Module, Producer: chunkmap.Producer{ - InputModule: chunkResult.record.Producer.InputModule, - ChunkModule: chunkResult.record.Producer.ChunkModule, - LLMProfile: chunkResult.record.Producer.LLMProfile, + InputModule: adapter.Key(), + ChunkModule: chunker.Key(), + LLMProfile: chunkProfile, }, }) if buildErr != nil { @@ -303,7 +256,7 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err if chunkResult.outcome.Disposition == contracts.ProducerFallback { output.FallbackCount++ } - if err := r.runPreparedSteps(ctx, input, checkpoints, checkpointLoader, doc, sourceInput, sessionID, chunkResult.chunks, &output); err != nil { + if err := r.runPreparedSteps(ctx, input, doc, sourceInput, sessionID, chunkResult.chunks, &output); err != nil { return failOutput(output), err } } @@ -427,7 +380,7 @@ func hasIncompleteValidation(summaries []artifacts.ValidationSummary) bool { return false } -func (r *Runner) runPreparedSteps(ctx context.Context, input RunInput, checkpoints CheckpointRecorder, loader CheckpointLoader, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, chunks []source.Chunk, output *RunOutput) error { +func (r *Runner) runPreparedSteps(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, chunks []source.Chunk, output *RunOutput) error { for _, step := range input.Prepared.Steps { stepInput := input stepInput.stepID = step.ID @@ -438,7 +391,7 @@ func (r *Runner) runPreparedSteps(ctx context.Context, input RunInput, checkpoin stepInput.references = stepReferences stepInput.referenceReuseEligibility = buildStepReferenceReuseEligibility(step, output.normalizeReuseEligibility) output.Manifest.References = append(output.Manifest.References, referenceProvenance...) - laneOutput, laneErr := r.runLanes(ctx, stepInput, step, checkpoints, loader, doc, sourceInput, sessionID, chunks) + laneOutput, laneErr := r.runLanes(ctx, stepInput, step, doc, sourceInput, sessionID, chunks) if err := mergeLaneOutput(output, laneOutput); err != nil { return err } @@ -481,13 +434,6 @@ func validateRunInput(input RunInput) error { if input.Prepared == nil { return fmt.Errorf("prepared pipeline must not be nil") } - mode := effectiveChunkCacheMode(input.ChunkCacheMode) - if err := mode.Validate(); err != nil { - return err - } - if mode != ChunkCacheBypass && input.ChunkPlans == nil { - return fmt.Errorf("chunk plan store is required for %q mode", mode) - } if err := validateResolvedPipeline(input.Prepared.resolved); err != nil { return err } @@ -557,7 +503,7 @@ func manifestFromPipeline(input RunInput) artifacts.RunManifest { InputModule: pipeline.Input.Module, Chunker: pipeline.Chunk.Module, ChunkPlan: &artifacts.ChunkPlanManifest{ - Mode: string(effectiveChunkCacheMode(input.ChunkCacheMode)), + Mode: string(pipeline.ChunkControls.Cache), RequestedModule: pipeline.Chunk.Module, }, OutputEncoder: pipeline.Output.Module, @@ -617,34 +563,6 @@ func failOutput(output RunOutput) RunOutput { return output } -func recordCheckpointEvent(output *RunOutput, loader CheckpointLoader, stage string, stepID string, laneID string, moduleKey string, decision CheckpointDecision) { - if output == nil || loader == nil || !loader.Enabled() { - return - } - action := checkpointDecisionCategory(decision) - output.CheckpointEvents = append(output.CheckpointEvents, CheckpointEvent{ - Stage: stage, - StepID: stepID, - LaneID: laneID, - ModuleKey: moduleKey, - Action: action, - Category: checkpointDecisionCategory(decision), - ReasonCode: decision.ReasonCode, - Detail: decision.Detail, - Reason: decision.Reason, - }) -} - -func checkpointDecisionCategory(decision CheckpointDecision) CheckpointDecisionCategory { - if decision.Category != "" { - return decision.Category - } - if decision.Reused { - return CheckpointDecisionReused - } - return CheckpointDecisionExecuted -} - func populateOutputManifest(output *RunOutput) { if output == nil { return @@ -654,13 +572,6 @@ func populateOutputManifest(output *RunOutput) { if len(output.ValidationSummaries) > 0 { output.Manifest.ValidationSummaries = cloneValidationSummaries(output.ValidationSummaries) } - if len(output.CheckpointEvents) > 0 { - decisions := make([]artifacts.CheckpointDecisionManifest, 0, len(output.CheckpointEvents)) - for _, event := range output.CheckpointEvents { - decisions = append(decisions, artifacts.CheckpointDecisionManifest{Stage: event.Stage, StepID: event.StepID, LaneID: event.LaneID, ModuleKey: event.ModuleKey, Category: string(event.Category), ReasonCode: string(event.ReasonCode), Detail: event.Detail}) - } - output.Manifest.CheckpointDecisions = decisions - } } func normalizedOutputManifests(outputs []contracts.SerializedOutput) []artifacts.NormalizedOutputManifest { diff --git a/internal/framework/pipeline/runner_accepted_checkpoint_test.go b/internal/framework/pipeline/runner_accepted_checkpoint_test.go deleted file mode 100644 index f177b1c7..00000000 --- a/internal/framework/pipeline/runner_accepted_checkpoint_test.go +++ /dev/null @@ -1,396 +0,0 @@ -package pipeline - -import ( - "context" - "encoding/json" - "reflect" - "strings" - "testing" - - "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" -) - -type acceptedCheckpointLoader struct { - CheckpointLoader - accepted map[string]NormalizeCheckpoint - acceptedDecision map[string]CheckpointDecision - extractDeps map[string][]CheckpointFingerprint -} - -func newAcceptedCheckpointLoader() *acceptedCheckpointLoader { - return &acceptedCheckpointLoader{ - CheckpointLoader: NoopCheckpointLoader(), - accepted: make(map[string]NormalizeCheckpoint), - acceptedDecision: make(map[string]CheckpointDecision), - extractDeps: make(map[string][]CheckpointFingerprint), - } -} - -func (l *acceptedCheckpointLoader) Enabled() bool { return true } -func (l *acceptedCheckpointLoader) AcceptedNormalize(stepID, laneID, _ string) (NormalizeCheckpoint, CheckpointDecision) { - key := CheckpointLaneKey(stepID, laneID) - return l.accepted[key], l.acceptedDecision[key] -} -func (l *acceptedCheckpointLoader) Extract(laneID string, _ string, dependencies []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) { - l.extractDeps[laneID] = append([]CheckpointFingerprint(nil), dependencies...) - return ExtractCheckpoint{}, NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonMissing) -} -func (l *acceptedCheckpointLoader) Merge(_ string, _ string, _ []CheckpointFingerprint) (MergeCheckpoint, CheckpointDecision) { - return MergeCheckpoint{}, NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonMissing) -} -func (l *acceptedCheckpointLoader) Normalize(_ string, _ string, _ []CheckpointFingerprint) (NormalizeCheckpoint, CheckpointDecision) { - return NormalizeCheckpoint{}, NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonMissing) -} - -func TestRunnerHydratesRequiredNormalizedArtifact(t *testing.T) { - value := codecNotes{Items: []string{"canonical producer value"}} - input, _, _ := handoffFixture(t, value) - prepared := input.Prepared - producer := &prepared.Steps[0].lanes[0] - consumer := &prepared.Steps[1].lanes[0] - doc := prepared.input.(*typedTestInput).doc - stored, err := checkpointArtifact(producer.typed.codec, producer.resolved.ID, producer.resolved.Normalize.Module, doc.ID, value) - if err != nil { - t.Fatal(err) - } - - operationCalls := 0 - producer.typed.extract = func(context.Context, any, contracts.TypedExtractionRequest) (erasedTypedResult, error) { - operationCalls++ - return erasedTypedResult{Value: value}, nil - } - producer.typed.merge = func(context.Context, any, contracts.TypedMergeRequest[any]) (erasedTypedResult, error) { - operationCalls++ - return erasedTypedResult{Value: value}, nil - } - producer.typed.normalize = func(context.Context, any, contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) { - operationCalls++ - return erasedTypedResult{Value: value}, nil - } - validatorCalls := 0 - validator := preparedValidator{typedValidate: func(context.Context, any, typedValidationTarget) (contracts.ValidationResult, error) { - validatorCalls++ - return contracts.ValidationResult{Approved: true}, nil - }} - producer.extractValidators.validators = []preparedValidator{validator} - producer.mergeValidators.validators = []preparedValidator{validator} - producer.normalizeValidators.validators = []preparedValidator{validator} - - var received contracts.ReferenceSet - consumer.typed.extract = func(_ context.Context, _ any, request contracts.TypedExtractionRequest) (erasedTypedResult, error) { - received = CloneReferenceSet(request.References) - return erasedTypedResult{Value: codecScore{Value: 3}}, nil - } - loader := newAcceptedCheckpointLoader() - producerKey := CheckpointLaneKey(producer.resolved.StepID, producer.resolved.ID) - consumerKey := CheckpointLaneKey(consumer.resolved.StepID, consumer.resolved.ID) - stored.Diagnostics = []CheckpointDiagnostic{{Diagnostic: contracts.ProducerDiagnostic{Disposition: contracts.DiagnosticDispositionWarning, Category: contracts.DiagnosticCategoryFallback, ReasonCode: "stored-warning", OccurrenceCount: 1, Samples: []contracts.DiagnosticSample{{Scope: "normalize", Message: "stored normalize warning"}}}}} - loader.accepted[producerKey] = NormalizeCheckpoint{Output: stored} - loader.acceptedDecision[producerKey] = NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused) - policy := CheckpointExecutionPolicy{ - RequireReusableLanes: map[string]struct{}{producerKey: {}}, - ForcedLanes: map[string]struct{}{consumerKey: {}}, - } - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), Checkpoint: loader, CheckpointPolicy: policy}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if operationCalls != 0 || validatorCalls != 0 { - t.Fatalf("hydrated producer calls = operations %d validators %d, want zero", operationCalls, validatorCalls) - } - item := received.Slots["producer-output"].Items[0] - if string(item.Content) != string(stored.Artifact.Content) || item.Producer.StepID != producer.resolved.StepID || item.Producer.LaneID != producer.resolved.ID { - t.Fatalf("consumer generated reference = %#v, want exact hydrated producer bytes and identity", item) - } - if len(output.Diagnostics.Groups) != 1 || output.Diagnostics.Groups[0].ReasonCode != "stored-warning" { - t.Fatalf("hydrated diagnostics = %#v, want normalize checkpoint diagnostics only", output.Diagnostics) - } - assertAcceptedNormalizeEvent(t, output.CheckpointEvents, producer.resolved.StepID, producer.resolved.ID, CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused) - for _, event := range output.CheckpointEvents { - if event.StepID == producer.resolved.StepID && event.LaneID == producer.resolved.ID && event.Stage != string(StageNormalize) { - t.Fatalf("hydrated producer synthesized checkpoint event: %#v", event) - } - } - - freshInput, _, _ := handoffFixture(t, value) - freshPrepared := freshInput.Prepared - freshPrepared.Steps[0].lanes[0].typed.extract = func(context.Context, any, contracts.TypedExtractionRequest) (erasedTypedResult, error) { - return erasedTypedResult{Value: value}, nil - } - freshPrepared.Steps[0].lanes[0].typed.normalize = func(context.Context, any, contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) { - return erasedTypedResult{Value: value}, nil - } - freshPrepared.Steps[1].lanes[0].typed.extract = func(context.Context, any, contracts.TypedExtractionRequest) (erasedTypedResult, error) { - return erasedTypedResult{Value: codecScore{Value: 3}}, nil - } - freshLoader := &handoffDependencyLoader{CheckpointLoader: NoopCheckpointLoader()} - freshOutput, err := New().Run(context.Background(), RunInput{Prepared: freshPrepared, RawInput: []byte("input"), Checkpoint: freshLoader}) - if err != nil { - t.Fatalf("fresh Run() error = %v", err) - } - hydratedDependencies := loader.extractDeps[consumer.resolved.ID] - if generatedFingerprintCount(hydratedDependencies) != 1 { - t.Fatalf("hydrated consumer dependencies = %#v, want generated producer fingerprint", hydratedDependencies) - } - var matchedFreshDependencies bool - for _, dependencies := range freshLoader.extract { - if reflect.DeepEqual(dependencies, hydratedDependencies) { - matchedFreshDependencies = true - break - } - } - if !matchedFreshDependencies { - t.Fatalf("consumer dependencies differ: fresh %#v hydrated %#v", freshLoader.extract, hydratedDependencies) - } - if !reflect.DeepEqual(freshOutput.Manifest.References, output.Manifest.References) { - t.Fatalf("generated provenance differs: fresh %#v hydrated %#v", freshOutput.Manifest.References, output.Manifest.References) - } -} - -func TestRunnerRejectsInvalidRequiredNormalizedArtifactBeforeConsumer(t *testing.T) { - const contentSentinel = "sensitive-campaign-payload-74291" - tests := []struct { - name string - decision CheckpointDecision - mutate func(*CheckpointArtifact) - wantCode CheckpointReasonCode - }{ - {"missing", NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonMissing), nil, CheckpointReasonMissing}, - {"rejected status", NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonStatusNotReusable), nil, CheckpointReasonStatusNotReusable}, - {"corrupt payload", NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused), func(v *CheckpointArtifact) { v.Artifact.Content = []byte(`{"items":[`) }, CheckpointReasonArtifactPayloadInvalid}, - {"non canonical", NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused), func(v *CheckpointArtifact) { v.Artifact.Content = []byte(`{"items": ["stored"]}`) }, CheckpointReasonArtifactNotCanonical}, - {"wrong codec identity", NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused), func(v *CheckpointArtifact) { v.Artifact.Kind = "test/score" }, CheckpointReasonArtifactCodecIncompatible}, - {"wrong content digest", NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonArtifactDigestMismatch), nil, CheckpointReasonArtifactDigestMismatch}, - } - for _, test := range tests { - t.Run(test.name, func(t *testing.T) { - input, _, _ := handoffFixture(t, codecNotes{Items: []string{contentSentinel}}) - prepared := input.Prepared - producer := &prepared.Steps[0].lanes[0] - consumer := &prepared.Steps[1].lanes[0] - doc := prepared.input.(*typedTestInput).doc - stored, err := checkpointArtifact(producer.typed.codec, producer.resolved.ID, producer.resolved.Normalize.Module, doc.ID, codecNotes{Items: []string{contentSentinel}}) - if err != nil { - t.Fatal(err) - } - if test.mutate != nil { - test.mutate(&stored) - } - consumerCalls := 0 - consumer.typed.extract = func(context.Context, any, contracts.TypedExtractionRequest) (erasedTypedResult, error) { - consumerCalls++ - return erasedTypedResult{Value: codecScore{Value: 1}}, nil - } - loader := newAcceptedCheckpointLoader() - producerKey := CheckpointLaneKey(producer.resolved.StepID, producer.resolved.ID) - loader.accepted[producerKey] = NormalizeCheckpoint{Output: stored} - loader.acceptedDecision[producerKey] = test.decision - policy := CheckpointExecutionPolicy{RequireReusableLanes: map[string]struct{}{producerKey: {}}} - output, runErr := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), Checkpoint: loader, CheckpointPolicy: policy}) - if runErr == nil || !strings.Contains(runErr.Error(), string(test.wantCode)) || consumerCalls != 0 { - t.Fatalf("Run() error = %v consumer calls = %d, want %q before consumer", runErr, consumerCalls, test.wantCode) - } - assertAcceptedNormalizeEvent(t, output.CheckpointEvents, producer.resolved.StepID, producer.resolved.ID, CheckpointDecisionExecuted, test.wantCode) - encoded, err := json.Marshal(struct { - Manifest any - Events any - Error string - }{output.Manifest, output.CheckpointEvents, runErr.Error()}) - if err != nil { - t.Fatal(err) - } - if strings.Contains(string(encoded), contentSentinel) || strings.Contains(string(encoded), string(stored.Artifact.Content)) { - t.Fatalf("failed hydration diagnostics leaked artifact content: %s", encoded) - } - }) - } -} - -func TestRunnerRetainsEarlierHydratedProducerWhenLaterRequiredProducerFails(t *testing.T) { - prepared := preparedPipelineWithSharedProducerStep(t) - first := &prepared.Steps[0].lanes[0] - second := &prepared.Steps[0].lanes[1] - consumer := &prepared.Steps[1].lanes[0] - doc := prepared.input.(*typedTestInput).doc - - stored, err := checkpointArtifact(first.typed.codec, first.resolved.ID, first.resolved.Normalize.Module, doc.ID, codecNotes{Items: []string{"retained producer"}}) - if err != nil { - t.Fatal(err) - } - consumerCalls := 0 - consumer.typed.extract = func(context.Context, any, contracts.TypedExtractionRequest) (erasedTypedResult, error) { - consumerCalls++ - return erasedTypedResult{Value: codecScore{Value: 1}}, nil - } - - loader := newAcceptedCheckpointLoader() - firstKey := CheckpointLaneKey(first.resolved.StepID, first.resolved.ID) - secondKey := CheckpointLaneKey(second.resolved.StepID, second.resolved.ID) - stored.Diagnostics = []CheckpointDiagnostic{{Diagnostic: contracts.ProducerDiagnostic{Disposition: contracts.DiagnosticDispositionWarning, Category: contracts.DiagnosticCategoryFallback, ReasonCode: "retained-warning", OccurrenceCount: 1, Samples: []contracts.DiagnosticSample{{Scope: "normalize", Message: "retained warning"}}}}} - loader.accepted[firstKey] = NormalizeCheckpoint{Output: stored} - loader.acceptedDecision[firstKey] = NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused) - loader.acceptedDecision[secondKey] = NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonMissing) - policy := CheckpointExecutionPolicy{RequireReusableLanes: map[string]struct{}{firstKey: {}, secondKey: {}}} - - output, runErr := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), Checkpoint: loader, CheckpointPolicy: policy}) - if runErr == nil || !strings.Contains(runErr.Error(), string(CheckpointReasonMissing)) { - t.Fatalf("Run() error = %v, want missing required producer", runErr) - } - if consumerCalls != 0 { - t.Fatalf("consumer calls = %d, want zero", consumerCalls) - } - if len(output.NormalizeOutputs) != 1 || output.NormalizeOutputs[0].LaneID != first.resolved.ID || string(output.NormalizeOutputs[0].Artifact.Content) != string(stored.Artifact.Content) { - t.Fatalf("retained normalize outputs = %#v, want first producer", output.NormalizeOutputs) - } - if len(output.Diagnostics.Groups) != 1 || output.Diagnostics.Groups[0].ReasonCode != "retained-warning" { - t.Fatalf("retained diagnostics = %#v", output.Diagnostics) - } - type decisionExpectation struct { - step, lane string - category CheckpointDecisionCategory - reason CheckpointReasonCode - } - want := []decisionExpectation{ - {first.resolved.StepID, first.resolved.ID, CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused}, - {second.resolved.StepID, second.resolved.ID, CheckpointDecisionExecuted, CheckpointReasonMissing}, - } - var got []decisionExpectation - for _, event := range output.CheckpointEvents { - if event.Stage == string(StageNormalize) { - got = append(got, decisionExpectation{event.StepID, event.LaneID, event.Category, event.ReasonCode}) - } - } - if !reflect.DeepEqual(got, want) { - t.Fatalf("normalize decisions = %#v, want %#v", got, want) - } - var manifestGot []decisionExpectation - for _, decision := range output.Manifest.CheckpointDecisions { - if decision.Stage == string(StageNormalize) { - manifestGot = append(manifestGot, decisionExpectation{ - decision.StepID, decision.LaneID, - CheckpointDecisionCategory(decision.Category), CheckpointReasonCode(decision.ReasonCode), - }) - } - } - if !reflect.DeepEqual(manifestGot, want) { - t.Fatalf("manifest normalize decisions = %#v, want %#v", manifestGot, want) - } -} - -func preparedPipelineWithSharedProducerStep(t *testing.T) *PreparedPipeline { - t.Helper() - catalog := typedResolutionCatalog(t, completeTypedCatalogOptions()) - base := typedResolutionProfile() - profile := base - profile.Artifacts = nil - profile.Steps = []PipelineStepProfile{ - {ID: "producers", Artifacts: map[string]ArtifactLaneProfile{"first": base.Artifacts["notes"], "second": base.Artifacts["notes"]}}, - {ID: "consumer", Artifacts: map[string]ArtifactLaneProfile{"score": base.Artifacts["score"]}}, - } - resolved, err := ResolvePipeline(profile, ResolveOptions{}, catalog) - if err != nil { - t.Fatalf("ResolvePipeline() error = %v", err) - } - prepared, err := Prepare(resolved, registriesFromModuleCatalog(catalog), ModuleDependencies{}) - if err != nil { - t.Fatalf("Prepare() error = %v", err) - } - doc := typedTestDocumentWithUnits(1) - prepared.input.(*typedTestInput).doc = doc - prepared.chunker = &typedTestChunker{key: "typed/chunk", plan: typedTestPlan(doc)} - return prepared -} - -func TestForcedRequiredLaneExecutesInsteadOfHydrating(t *testing.T) { - prepared := preparedOrderedPipeline(t, 1, - orderedLaneSpec{id: "unrelated", profile: "score"}, - orderedLaneSpec{id: "producer", profile: "notes"}, - orderedLaneSpec{id: "consumer", profile: "score"}, - ) - unrelated := &prepared.Steps[0].lanes[0] - producer := &prepared.Steps[1].lanes[0] - consumer := &prepared.Steps[2].lanes[0] - installGeneratedReferenceTarget(&consumer.resolved.ExtractReferences, StageExtract, consumer, "step-2", "producer") - - doc := prepared.input.(*typedTestInput).doc - unrelatedArtifact, err := checkpointArtifact(unrelated.typed.codec, unrelated.resolved.ID, unrelated.resolved.Normalize.Module, doc.ID, codecScore{Value: 9}) - if err != nil { - t.Fatal(err) - } - producerArtifact, err := checkpointArtifact(producer.typed.codec, producer.resolved.ID, producer.resolved.Normalize.Module, doc.ID, codecNotes{Items: []string{"stale"}}) - if err != nil { - t.Fatal(err) - } - unrelatedCalls, producerCalls := 0, 0 - unrelated.typed.extract = func(context.Context, any, contracts.TypedExtractionRequest) (erasedTypedResult, error) { - unrelatedCalls++ - return erasedTypedResult{Value: codecScore{Value: 9}}, nil - } - producer.typed.extract = func(context.Context, any, contracts.TypedExtractionRequest) (erasedTypedResult, error) { - producerCalls++ - return erasedTypedResult{Value: codecNotes{Items: []string{"fresh"}}}, nil - } - producer.typed.normalize = func(context.Context, any, contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) { - return erasedTypedResult{Value: codecNotes{Items: []string{"fresh"}}}, nil - } - var consumerReferences contracts.ReferenceSet - consumer.typed.extract = func(_ context.Context, _ any, request contracts.TypedExtractionRequest) (erasedTypedResult, error) { - consumerReferences = CloneReferenceSet(request.References) - return erasedTypedResult{Value: codecScore{Value: 1}}, nil - } - loader := newAcceptedCheckpointLoader() - unrelatedKey := CheckpointLaneKey(unrelated.resolved.StepID, unrelated.resolved.ID) - producerKey := CheckpointLaneKey(producer.resolved.StepID, producer.resolved.ID) - consumerKey := CheckpointLaneKey(consumer.resolved.StepID, consumer.resolved.ID) - loader.accepted[unrelatedKey] = NormalizeCheckpoint{Output: unrelatedArtifact} - loader.acceptedDecision[unrelatedKey] = NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused) - loader.accepted[producerKey] = NormalizeCheckpoint{Output: producerArtifact} - loader.acceptedDecision[producerKey] = NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused) - policy := CheckpointExecutionPolicy{ - ForcedLanes: map[string]struct{}{producerKey: {}, consumerKey: {}}, - RequireReusableLanes: map[string]struct{}{unrelatedKey: {}, producerKey: {}}, - } - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), Checkpoint: loader, CheckpointPolicy: policy}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if producerCalls == 0 || unrelatedCalls != 0 { - t.Fatalf("calls producer=%d unrelated=%d, want forced producer execution and unrelated hydration", producerCalls, unrelatedCalls) - } - if got := string(consumerReferences.Slots["producer-output"].Items[0].Content); !strings.Contains(got, "fresh") || strings.Contains(got, "stale") { - t.Fatalf("forced producer reference = %q, want freshly executed output", got) - } - assertAcceptedNormalizeEvent(t, output.CheckpointEvents, unrelated.resolved.StepID, unrelated.resolved.ID, CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused) - assertAcceptedNormalizeEvent(t, output.CheckpointEvents, producer.resolved.StepID, producer.resolved.ID, CheckpointDecisionForcedRecompute, CheckpointReasonRecomputeStep) -} - -func installGeneratedReferenceTarget(target *ResolvedReferenceTarget, stage ModuleStage, consumer *preparedLaneExecutor, producerStep, producerLane string) { - *target = ResolvedReferenceTarget{ - Stage: stage, - StepID: consumer.resolved.StepID, - LaneID: consumer.resolved.ID, - Module: consumer.resolved.Extract.Module, - Bindings: []ReferenceBinding{{ - Stage: stage, - LaneID: consumer.resolved.ID, - SlotName: "producer-output", - Artifact: &ArtifactReference{Step: producerStep, Lane: producerLane}, - }}, - ReferenceSet: contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ - "producer-output": {Slot: contracts.ReferenceSlot{Name: "producer-output", AcceptedArtifactKinds: []contracts.ArtifactKind{"test/notes"}, AcceptedMediaTypes: []string{"application/json"}}}, - }}, - } -} - -func assertAcceptedNormalizeEvent(t *testing.T, events []CheckpointEvent, stepID, laneID string, category CheckpointDecisionCategory, code CheckpointReasonCode) { - t.Helper() - for _, event := range events { - if event.Stage == string(StageNormalize) && event.StepID == stepID && event.LaneID == laneID { - if event.Category != category || event.ReasonCode != code { - t.Fatalf("accepted normalize event = %#v, want %q/%q", event, category, code) - } - return - } - } - t.Fatalf("accepted normalize event missing from %#v", events) -} diff --git a/internal/framework/pipeline/runner_cache.go b/internal/framework/pipeline/runner_cache.go index eb69c712..511267a3 100644 --- a/internal/framework/pipeline/runner_cache.go +++ b/internal/framework/pipeline/runner_cache.go @@ -36,29 +36,33 @@ func artifactProducerCache(input RunInput, typed *preparedTypedLane, class contr } return value, nil }, - Observe: func(ctx context.Context, observation contracts.CacheObservation) error { - if chunk != nil { - chunkIndex := chunk.Index - observation.ChunkID, observation.ChunkIndex = chunk.ID, &chunkIndex - } - if observation.Err != nil { - message := strings.ToValidUTF8(fmt.Sprintf("Artifact cache %s: %v", observation.Decision, observation.Err), "�") - if len(message) > contracts.MaxDiagnosticMessageBytes { - message = message[:contracts.MaxDiagnosticMessageBytes] - for !utf8.ValidString(message) { - message = message[:len(message)-1] - } - } - *warnings = append(*warnings, contracts.ProducerDiagnostic{ - Disposition: contracts.DiagnosticDispositionWarning, Category: contracts.DiagnosticCategoryDegradation, - ReasonCode: "cache_" + observation.Decision, OccurrenceCount: 1, - Samples: []contracts.DiagnosticSample{{Scope: origin.ModuleKey, Message: message}}, - }) - } - if input.ObserveCache != nil { - return input.ObserveCache(ctx, origin, observation) - } - return nil - }, + Observe: producerCacheObserver(input, origin, chunk, warnings), + } +} + +func producerCacheObserver(input RunInput, origin contracts.DiagnosticOrigin, chunk *source.Chunk, warnings *[]contracts.ProducerDiagnostic) func(context.Context, contracts.CacheObservation) error { + return func(ctx context.Context, observation contracts.CacheObservation) error { + if chunk != nil { + chunkIndex := chunk.Index + observation.ChunkID, observation.ChunkIndex = chunk.ID, &chunkIndex + } + if observation.Err != nil { + message := strings.ToValidUTF8(fmt.Sprintf("Artifact cache %s: %v", observation.Decision, observation.Err), "�") + if len(message) > contracts.MaxDiagnosticMessageBytes { + message = message[:contracts.MaxDiagnosticMessageBytes] + for !utf8.ValidString(message) { + message = message[:len(message)-1] + } + } + *warnings = append(*warnings, contracts.ProducerDiagnostic{ + Disposition: contracts.DiagnosticDispositionWarning, Category: contracts.DiagnosticCategoryDegradation, + ReasonCode: "cache_" + observation.Decision, OccurrenceCount: 1, + Samples: []contracts.DiagnosticSample{{Scope: origin.ModuleKey, Message: message}}, + }) + } + if input.ObserveCache != nil { + return input.ObserveCache(ctx, origin, observation) + } + return nil } } diff --git a/internal/framework/pipeline/runner_chunk_plan.go b/internal/framework/pipeline/runner_chunk_plan.go index c8009cfa..b7154866 100644 --- a/internal/framework/pipeline/runner_chunk_plan.go +++ b/internal/framework/pipeline/runner_chunk_plan.go @@ -1,11 +1,12 @@ package pipeline import ( + "bytes" "context" + "encoding/json" "fmt" - "time" + "io" - "gitea.maximumdirect.net/eric/notarius/internal/core/artifacts" "gitea.maximumdirect.net/eric/notarius/internal/core/source" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" ) @@ -16,32 +17,18 @@ type chunkPlanExecution struct { chunks []source.Chunk plan *source.ChunkPlan diagnostics []contracts.DiagnosticGroup - rejection *contracts.RejectedOutput - lookup ChunkPlanDecision - record *ChunkPlanRecord - action string - summary artifacts.ChunkPlanSummary - validation *artifacts.ValidationSummary } -func effectiveChunkCacheMode(mode ChunkCacheMode) ChunkCacheMode { - if mode == "" { - return ChunkCacheBypass - } - parsed, _ := ParseChunkCacheMode(string(mode)) - return parsed -} - -// Chunk-plan lookup and publication happen serially before lane workers start. -// The runner therefore does not add synchronization around the store. +// Chunk planning remains serial before lane workers. Only a native chunk +// producer uses the accepted-artifact cache; deterministic plans run directly. func (r *Runner) runChunkPlan(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string) (chunkPlanExecution, error) { - mode := effectiveChunkCacheMode(input.ChunkCacheMode) chunker := input.Prepared.chunker - result := chunkPlanExecution{lookup: ChunkPlanDecision{Reason: "chunk plan lookup skipped"}, summary: artifacts.ChunkPlanSummary{Mode: string(mode), SourceDigest: doc.Digest, RequestedModule: chunker.Key(), LookupStatus: "skipped", LookupReason: "chunk plan lookup skipped", ValidationStatus: "not_run", PublicationStatus: "not_requested"}} + result := chunkPlanExecution{} + origin := contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageChunk, ModuleKey: chunker.Key()} target := typedValidationTarget{stage: StageChunk, moduleKey: chunker.Key(), source: doc, sourceID: doc.ID, sourceInput: sourceInput.Clone(), sessionID: sessionID, references: input.pipeline.ChunkReferences.ReferenceSet, metadata: input.Metadata, execution: input.Execution} assessChunks := chunkCandidateAssessor(target, input.Prepared.chunkValidators) var assessment contracts.CandidateAssessment - operation := contracts.ProducerOperation[source.ChunkPlan]{Controls: input.pipeline.ChunkControls, Execution: input.Execution, ReuseEligible: true, + operation := contracts.ProducerOperation[source.ChunkPlan]{Controls: input.pipeline.ChunkControls, Execution: input.Execution, ReuseEligible: !input.reuseIneligible, Assess: func(ctx context.Context, plan source.ChunkPlan) (contracts.CandidateAssessment, error) { _, chunks, err := validateAndMaterializeChunkPlan(doc, plan) if err != nil { @@ -55,35 +42,32 @@ func (r *Runner) runChunkPlan(ctx context.Context, input RunInput, doc *source.S return assessment, err }, } - if mode == ChunkCacheAuto { - record, decision, err := input.ChunkPlans.Load(doc.Digest) - if err != nil { - return result, fmt.Errorf("load chunk plan: %w", err) - } - result.lookup = decision - result.summary.LookupStatus, result.summary.LookupReason = chunkPlanLookupStatus(decision.Status), chunkPlanLookupReason(decision.Status) - if decision.Status == ChunkPlanHit { - plan, chunks, err := validateAndMaterializeChunkPlan(doc, record.Plan) - if err == nil { - cachedAssessment, err := assessChunks(ctx, chunks) + var cacheDiagnostics []contracts.ProducerDiagnostic + if input.Cache != nil && input.pipeline.ChunkExecutionClass == contracts.ExecutionClassLLMBacked { + operation.Cache = &contracts.ProducerCache[source.ChunkPlan]{ + Store: input.Cache, + Encode: func(plan source.ChunkPlan) ([]byte, error) { + canonical, _, err := validateAndMaterializeChunkPlan(doc, plan) if err != nil { - return result, err + return nil, err } - if cachedAssessment.Accepted() { - if err := result.setCandidate(record, "reused"); err != nil { - return result, err - } - result.plan, result.chunks, result.accepted = &plan, chunks, true - result.outcome = contracts.ProducerOutcome{Disposition: contracts.ProducerAccepted, ReuseEligible: true} - result.diagnostics, err = operationDiagnosticGroups(record.Diagnostics, nil, cachedAssessment, result.outcome, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageChunk, ModuleKey: chunker.Key()}, nil) - result.setValidation(nil, err) - return result, err + return json.Marshal(canonical) + }, + Decode: func(content []byte) (source.ChunkPlan, error) { + var plan source.ChunkPlan + decoder := json.NewDecoder(bytes.NewReader(content)) + decoder.DisallowUnknownFields() + if err := decoder.Decode(&plan); err != nil { + return source.ChunkPlan{}, err } - } - result.lookup = ChunkPlanDecision{Status: ChunkPlanInvalid, Reason: chunkPlanLookupReason(ChunkPlanInvalid)} - result.summary.LookupStatus, result.summary.LookupReason = "invalid", chunkPlanLookupReason(ChunkPlanInvalid) - } else if decision.Status != ChunkPlanMissing && decision.Status != ChunkPlanInvalid { - return result, fmt.Errorf("load chunk plan returned unsupported decision status") + var trailing any + if err := decoder.Decode(&trailing); err != io.EOF { + return source.ChunkPlan{}, fmt.Errorf("cached chunk plan must contain one JSON value") + } + canonical, _, err := validateAndMaterializeChunkPlan(doc, plan) + return canonical, err + }, + Observe: producerCacheObserver(input, origin, nil, &cacheDiagnostics), } } metadata, err := cloneMetadata(input.Metadata) @@ -105,142 +89,7 @@ func (r *Runner) runChunkPlan(ctx context.Context, input RunInput, doc *source.S if err != nil { return result, fmt.Errorf("materialize final chunk plan: %w", err) } - digest, err := source.DigestChunkPlan(plan) - if err != nil { - return result, err - } - producerMetadata, _, err := moduleManifestMetadata(chunker) - if err != nil { - return result, err - } - profile := "" - if input.pipeline.ChunkExecutionClass == contracts.ExecutionClassLLMBacked { - profile = input.pipeline.Chunk.LLMProfile - } - record := ChunkPlanRecord{SchemaVersion: ChunkPlanSchemaVersion, SourceDigest: doc.Digest, PlanDigest: digest, Plan: source.CloneChunkPlan(plan), CreatedAt: time.Now().UTC(), - Producer: ChunkPlanProducer{InputModule: input.Prepared.input.Key(), ChunkModule: chunker.Key(), LLMProfile: profile, References: append([]artifacts.ReferenceProvenance(nil), referenceTargetProvenance(input.pipeline.ChunkReferences)...), Metadata: producerMetadata}, - } - if err := result.setCandidate(record, "generated"); err != nil { - return result, err - } - if mode == ChunkCacheRefresh { - result.action, result.summary.Action = "refreshed", "refreshed" - } - if mode == ChunkCacheBypass { - result.action, result.summary.Action = "bypassed", "bypassed" - } result.plan, result.chunks, result.accepted, result.outcome = &plan, chunks, true, outcome - result.setValidation(nil, nil) - if outcome.Disposition == contracts.ProducerFallback { - result.summary.ValidationStatus = "incomplete" - } - result.diagnostics, err = operationDiagnosticGroups(produced.Diagnostics, nil, assessment, outcome, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageChunk, ModuleKey: chunker.Key()}, nil) - if err != nil { - return result, err - } - if mode == ChunkCacheAuto || mode == ChunkCacheRefresh { - result.summary.PublicationStatus = "not_published" - if outcome.ReuseEligible { - record.Diagnostics = contracts.CloneProducerDiagnostics(produced.Diagnostics) - if err := input.ChunkPlans.Save(record); err != nil { - return result, fmt.Errorf("save chunk plan: %w", err) - } - result.summary.PublicationStatus = "published" - } - } - return result, nil -} - -func chunkPlanLookupStatus(status ChunkPlanStatus) string { - switch status { - case ChunkPlanHit: - return "hit" - case ChunkPlanMissing: - return "missing" - case ChunkPlanInvalid: - return "invalid" - default: - return "skipped" - } -} - -func chunkPlanLookupReason(status ChunkPlanStatus) string { - switch status { - case ChunkPlanHit: - return "stored chunk plan is valid" - case ChunkPlanMissing: - return "chunk plan not found" - case ChunkPlanInvalid: - return "stored chunk plan is invalid" - default: - return "chunk plan lookup skipped" - } -} - -func (result *chunkPlanExecution) setCandidate(record ChunkPlanRecord, action string) error { - cloned, err := cloneChunkPlanRecord(record) - if err != nil { - return err - } - result.record = &cloned - result.action = action - result.summary.Action = action - result.summary.SourceDigest = record.SourceDigest - result.summary.CandidateDigest = record.PlanDigest - return nil -} - -func (result *chunkPlanExecution) setValidation(rejection *contracts.RejectedOutput, err error) { - switch { - case err != nil: - result.summary.ValidationStatus = "error" - case rejection != nil: - result.summary.ValidationStatus = "rejected" - default: - result.summary.ValidationStatus = "approved" - } -} - -func cloneChunkPlanRecord(record ChunkPlanRecord) (ChunkPlanRecord, error) { - record.Plan = source.CloneChunkPlan(record.Plan) - record.Producer.References = append([]artifacts.ReferenceProvenance(nil), record.Producer.References...) - metadata, err := cloneMetadata(record.Producer.Metadata) - if err != nil { - return ChunkPlanRecord{}, fmt.Errorf("clone chunk plan producer metadata: %w", err) - } - record.Producer.Metadata = metadata - record.Diagnostics = contracts.CloneProducerDiagnostics(record.Diagnostics) - return record, nil -} - -func applyChunkPlanExecution(output *RunOutput, result chunkPlanExecution) error { - if output == nil { - return nil - } - summary := result.summary - output.ChunkPlan = &summary - if output.Manifest.ChunkPlan == nil { - return nil - } - manifest := output.Manifest.ChunkPlan - manifest.Action = result.action - if result.record == nil { - return nil - } - record := result.record - manifest.SourceDigest = record.SourceDigest - manifest.PlanDigest = record.PlanDigest - manifest.PlanSchemaVersion = record.SchemaVersion - manifest.ProducerInputModule = record.Producer.InputModule - manifest.ProducerModule = record.Producer.ChunkModule - manifest.ProducerLLMProfile = record.Producer.LLMProfile - manifest.ProducerReferences = append([]artifacts.ReferenceProvenance(nil), record.Producer.References...) - metadata, err := cloneMetadata(record.Producer.Metadata) - if err != nil { - return fmt.Errorf("clone chunk plan manifest producer metadata: %w", err) - } - manifest.ProducerMetadata = metadata - createdAt := record.CreatedAt - manifest.CreatedAt = &createdAt - return nil + result.diagnostics, err = operationDiagnosticGroups(produced.Diagnostics, cacheDiagnostics, assessment, outcome, origin, nil) + return result, err } diff --git a/internal/framework/pipeline/runner_chunk_plan_test.go b/internal/framework/pipeline/runner_chunk_plan_test.go index 7e18f698..09a1770a 100644 --- a/internal/framework/pipeline/runner_chunk_plan_test.go +++ b/internal/framework/pipeline/runner_chunk_plan_test.go @@ -2,837 +2,91 @@ package pipeline import ( "context" - "encoding/json" - "errors" - "reflect" - "strings" "testing" - "time" - "gitea.maximumdirect.net/eric/notarius/internal/core/source" "gitea.maximumdirect.net/eric/notarius/internal/framework/chunkmap" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" + "go.maximumdirect.net/promptkit" ) -type recordingChunkPlanStore struct { - record ChunkPlanRecord - decision ChunkPlanDecision - loadErr error - saveErr error - loads int - saves int - saved ChunkPlanRecord -} - -func (s *recordingChunkPlanStore) Load(string) (ChunkPlanRecord, ChunkPlanDecision, error) { - s.loads++ - return s.record, s.decision, s.loadErr -} - -func (s *recordingChunkPlanStore) Save(record ChunkPlanRecord) error { - s.saves++ - s.saved = record - return s.saveErr -} - -type countingChunkValidator struct { - calls int - result contracts.ValidationResult - err error -} - -type capturingChunkMapOutput struct { - requests []contracts.OutputRequest -} +type capturingChunkMapOutput struct{ requests []contracts.OutputRequest } func (*capturingChunkMapOutput) Key() string { return "capture/chunk-map" } - func (output *capturingChunkMapOutput) Encode(_ context.Context, request contracts.OutputRequest) (contracts.OutputResult, error) { output.requests = append(output.requests, request) return contracts.OutputResult{}, nil } -func (*countingChunkValidator) Name() string { return "test/counting-chunks" } -func (*countingChunkValidator) ExecutionClass() contracts.ExecutionClass { - return contracts.ExecutionClassDeterministic -} -func (v *countingChunkValidator) Validate(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { - v.calls++ - return v.result, v.err -} - -type manifestChunker struct { - terminalChunker - metadata map[string]any -} - -func (c manifestChunker) ManifestMetadata() map[string]any { return c.metadata } - -type llmCountingChunker struct { - terminalChunker - llmCalls *int -} - -func (c llmCountingChunker) Plan(ctx context.Context, request contracts.ChunkRequest) (contracts.ChunkPlanResult, error) { - (*c.llmCalls)++ - return c.terminalChunker.Plan(ctx, request) -} - -type retryingChunker struct { - key string - plan source.ChunkPlan - calls int -} - -type correctionAwareChunker struct { - key string - plan source.ChunkPlan - calls int - correction *contracts.SemanticCorrection -} - -func (c *correctionAwareChunker) Key() string { return c.key } -func (*correctionAwareChunker) ReferenceSlots() []contracts.ReferenceSlot { return nil } -func (c *correctionAwareChunker) Plan(_ context.Context, request contracts.ChunkRequest) (contracts.ChunkPlanResult, error) { - c.calls++ - if request.Correction != nil { - correction, err := contracts.CloneSemanticCorrection(request.Correction) - if err != nil { - return contracts.ChunkPlanResult{}, err - } - c.correction = correction - } - response := "initial chunk response" - if c.calls > 1 { - response = "corrected chunk response" - } - candidate, err := contracts.NewModelCandidate([]byte(response), contracts.CorrectionProtocolSingleResponseV1) - if err != nil { - return contracts.ChunkPlanResult{}, err - } - return contracts.ChunkPlanResult{Plan: source.CloneChunkPlan(c.plan), ModelCandidate: candidate}, nil -} - -func (c *retryingChunker) Key() string { return c.key } -func (*retryingChunker) ReferenceSlots() []contracts.ReferenceSlot { return nil } -func (c *retryingChunker) Plan(context.Context, contracts.ChunkRequest) (contracts.ChunkPlanResult, error) { - c.calls++ - if c.calls == 1 { - return contracts.ChunkPlanResult{Diagnostics: []contracts.ProducerDiagnostic{producerDiagnostic("discarded", "discarded diagnostic")}}, errors.New("retry generation") - } - return contracts.ChunkPlanResult{Plan: source.CloneChunkPlan(c.plan), Diagnostics: []contracts.ProducerDiagnostic{producerDiagnostic("accepted", "accepted diagnostic")}}, nil -} - -type dependencyLoader struct { - CheckpointLoader - extractDependencies []CheckpointFingerprint -} - -func (l *dependencyLoader) Extract(_ string, _ string, dependencies []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) { - l.extractDependencies = append([]CheckpointFingerprint(nil), dependencies...) - return ExtractCheckpoint{}, CheckpointDecision{Reason: "not found"} -} - -func TestRunnerChunkPlanModeMatrix(t *testing.T) { - tests := []struct { - name string - mode ChunkCacheMode - decision ChunkPlanDecision - wantLoads int - wantSaves int - wantCalls int - wantAction string - }{ - {name: "auto hit", mode: ChunkCacheAuto, decision: ChunkPlanDecision{Status: ChunkPlanHit}, wantLoads: 1, wantAction: "reused"}, - {name: "auto missing", mode: ChunkCacheAuto, decision: ChunkPlanDecision{Status: ChunkPlanMissing}, wantLoads: 1, wantSaves: 1, wantCalls: 1, wantAction: "generated"}, - {name: "auto invalid", mode: ChunkCacheAuto, decision: ChunkPlanDecision{Status: ChunkPlanInvalid}, wantLoads: 1, wantSaves: 1, wantCalls: 1, wantAction: "generated"}, - {name: "bypass", mode: ChunkCacheBypass, wantCalls: 1, wantAction: "bypassed"}, - {name: "empty bypass", wantCalls: 1, wantAction: "bypassed"}, - {name: "refresh", mode: ChunkCacheRefresh, wantSaves: 1, wantCalls: 1, wantAction: "refreshed"}, - } - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - calls := 0 - llmCalls := 0 - prepared.chunker = llmCountingChunker{terminalChunker: terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls}, llmCalls: &llmCalls} - store := &recordingChunkPlanStore{record: chunkPlanRecord(t, prepared, plan), decision: tc.decision} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: tc.mode, ChunkPlans: store}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if store.loads != tc.wantLoads || store.saves != tc.wantSaves || calls != tc.wantCalls { - t.Fatalf("calls = load %d save %d module %d, want %d %d %d", store.loads, store.saves, calls, tc.wantLoads, tc.wantSaves, tc.wantCalls) - } - if output.Manifest.ChunkPlan == nil || output.Manifest.ChunkPlan.Action != tc.wantAction || output.ChunkPlan == nil || output.ChunkPlan.Action != tc.wantAction { - t.Fatalf("chunk plan manifest = %#v summary = %#v, want action %q", output.Manifest.ChunkPlan, output.ChunkPlan, tc.wantAction) - } - }) - } -} - -func TestRunnerUsesStatusDerivedChunkPlanSummaryReasons(t *testing.T) { - for _, tc := range []struct { - name string - status ChunkPlanStatus - wantStatus string - wantReason string - }{ - {name: "hit", status: ChunkPlanHit, wantStatus: "hit", wantReason: "stored chunk plan is valid"}, - {name: "missing", status: ChunkPlanMissing, wantStatus: "missing", wantReason: "chunk plan not found"}, - {name: "invalid", status: ChunkPlanInvalid, wantStatus: "invalid", wantReason: "stored chunk plan is invalid"}, - } { - t.Run(tc.name, func(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - store := &recordingChunkPlanStore{ - record: chunkPlanRecord(t, prepared, plan), - decision: ChunkPlanDecision{Status: tc.status, Reason: "SENTINEL_STORE_REASON"}, - } - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if err != nil { - t.Fatal(err) - } - if output.ChunkPlan.LookupStatus != tc.wantStatus || output.ChunkPlan.LookupReason != tc.wantReason || strings.Contains(output.ChunkPlan.LookupReason, "SENTINEL_STORE_REASON") { - t.Fatalf("summary = %#v", output.ChunkPlan) - } - }) - } - - prepared, _ := preparedTerminalDebugPipeline(t) - output, err := New().Run(context.Background(), RunInput{ - Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, - ChunkPlans: &recordingChunkPlanStore{loadErr: errors.New("read failed")}, - }) - if err == nil || output.ChunkPlan == nil || output.ChunkPlan.LookupStatus != "skipped" || output.ChunkPlan.LookupReason != "chunk plan lookup skipped" { - t.Fatalf("operational lookup output=%#v error=%v", output.ChunkPlan, err) - } -} - -func TestRunnerChunkPlanHitUsesStoredProducerProvenance(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.Chunk.Module = "chunk/requested" - prepared.resolved.Chunk.LLMProfile = "current-profile" - record := chunkPlanRecord(t, prepared, plan) - record.Producer.InputModule = "input/original" - record.Producer.ChunkModule = "chunk/original" - record.Producer.LLMProfile = "original-profile" - record.Producer.Metadata = map[string]any{"prompt": map[string]any{"id": "original"}} - store := &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if err != nil { - t.Fatal(err) - } - manifest := output.Manifest.ChunkPlan - if manifest.RequestedModule != "chunk/requested" || manifest.ProducerModule != "chunk/original" || manifest.ProducerLLMProfile != "original-profile" { - t.Fatalf("chunk plan manifest = %#v", manifest) - } - storedNested := record.Producer.Metadata["prompt"].(map[string]any) - storedNested["id"] = "mutated" - if got := manifest.ProducerMetadata["prompt"].(map[string]any)["id"]; got != "original" { - t.Fatalf("producer metadata changed through stored alias: %v", got) - } -} - -func TestRunnerReusesChunkPlanDiagnosticsWithCurrentValidatorDiagnostics(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - record := chunkPlanRecord(t, prepared, plan) - record.Diagnostics = []contracts.ProducerDiagnostic{{ - Disposition: contracts.DiagnosticDispositionWarning, - Category: contracts.DiagnosticCategoryConfiguration, - ReasonCode: "stored_chunk_diagnostic", - OccurrenceCount: 1, - Samples: []contracts.DiagnosticSample{{Scope: "reference", Message: "Stored configuration signal."}}, - }} - validator := &countingChunkValidator{result: contracts.ValidationResult{Approved: true, Diagnostics: []contracts.ProducerDiagnostic{{ - Disposition: contracts.DiagnosticDispositionAdvisory, - Category: contracts.DiagnosticCategoryDataQuality, - ReasonCode: "current_validator_diagnostic", - OccurrenceCount: 1, - Samples: []contracts.DiagnosticSample{{Scope: "chunk", Message: "Current validator finding."}}, - }}}} - prepared.chunkValidators.validators = []preparedValidator{{resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator}} - - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}}}) - if err != nil { - t.Fatal(err) - } - if validator.calls != 1 || len(output.Diagnostics.Groups) != 2 { - t.Fatalf("validator calls = %d diagnostics = %#v", validator.calls, output.Diagnostics) - } - if output.Diagnostics.Groups[0].ReasonCode != "stored_chunk_diagnostic" || output.Diagnostics.Groups[1].ReasonCode != "current_validator_diagnostic" || output.Diagnostics.Groups[1].Origin.ValidatorKey != validator.Name() { - t.Fatalf("diagnostic groups = %#v", output.Diagnostics.Groups) - } -} - func TestRunnerProvidesAcceptedChunkMapToOutput(t *testing.T) { - for _, test := range []struct { - name string - configure func(*PreparedPipeline, source.ChunkPlan) (RunInput, chunkmap.Producer) - }{ - { - name: "bypassed plan", - configure: func(prepared *PreparedPipeline, _ source.ChunkPlan) (RunInput, chunkmap.Producer) { - return RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheBypass}, chunkmap.Producer{ - InputModule: prepared.input.Key(), ChunkModule: prepared.chunker.Key(), - } - }, - }, - { - name: "cached plan", - configure: func(prepared *PreparedPipeline, plan source.ChunkPlan) (RunInput, chunkmap.Producer) { - prepared.resolved.Chunk.Module = "chunk/requested" - record := chunkPlanRecord(t, prepared, plan) - record.Producer.InputModule = "input/original" - record.Producer.ChunkModule = "chunk/original" - record.Producer.LLMProfile = "original-profile" - return RunInput{ - Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, - ChunkPlans: &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}}, - }, chunkmap.Producer{InputModule: "input/original", ChunkModule: "chunk/original", LLMProfile: "original-profile"} - }, - }, - } { - t.Run(test.name, func(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - encoder := &capturingChunkMapOutput{} - prepared.output = encoder - input, wantProducer := test.configure(prepared, plan) - if _, err := New().Run(context.Background(), input); err != nil { - t.Fatalf("Run() error = %v", err) - } - if len(encoder.requests) != 1 || encoder.requests[0].ChunkMap == nil { - t.Fatalf("output requests = %#v, want one accepted chunk map", encoder.requests) - } - artifact := encoder.requests[0].ChunkMap - if artifact.Kind != chunkmap.ArtifactKind || artifact.Schema.ID != chunkmap.SchemaID || artifact.MediaType != chunkmap.MediaType { - t.Fatalf("chunk map artifact = %#v, want fixed serialized identity", artifact) - } - value, err := chunkmap.New().Decode(artifact.Content) - if err != nil { - t.Fatalf("decode output chunk map: %v", err) - } - if value.RequestedChunker != prepared.resolved.Chunk.Module || value.Producer != wantProducer { - t.Fatalf("chunk map = %#v, want current request and producer %#v", value, wantProducer) - } - }) - } -} - -func TestRunnerOmitsChunkMapForRejectedPlan(t *testing.T) { - prepared, _ := preparedTerminalDebugPipeline(t) + calls, assessments := 0, 0 + engine := nativeProducerEngine(t, producerClientFunc(func(context.Context, promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { + calls++ + return planResponse(t, typedTestPlan(typedTestDocument())), nil + })) + input := planCacheRunInput(t, engine, func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { + assessments++ + return contracts.ValidationResult{Approved: true}, nil + }) + _, store := filesystemProducerCache(t) encoder := &capturingChunkMapOutput{} - prepared.output = encoder - prepared.chunkValidators.validators = []preparedValidator{{ - resolved: ResolvedValidator{Binding: Binding("reject/chunk"), Target: ValidatorTargetChunk}, - chunk: &countingChunkValidator{result: contracts.ValidationResult{Approved: false, ReasonCode: "rejected", Message: "not accepted", CorrectionGuidance: "return an acceptable chunk plan"}}, - }} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if len(output.Rejected) != 1 || len(encoder.requests) != 1 || encoder.requests[0].ChunkMap != nil { - t.Fatalf("output = %#v requests = %#v, want rejected plan without chunk map", output.Rejected, encoder.requests) - } -} - -func TestRunnerCorrectsRejectedGeneratedChunkPlan(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.ChunkExecutionClass = contracts.ExecutionClassLLMBacked - prepared.resolved.Chunk.Retries = 1 - chunker := &correctionAwareChunker{key: prepared.resolved.Chunk.Module, plan: plan} - prepared.chunker = chunker - validatorCalls := 0 - prepared.chunkValidators.validators = []preparedValidator{{ - resolved: ResolvedValidator{Binding: Binding("reject-then-approve"), Target: ValidatorTargetChunk}, - chunk: chunkValidationFunc{name: "reject-then-approve", validate: func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { - validatorCalls++ - if validatorCalls == 1 { - return contracts.ValidationResult{ReasonCode: "chunk_scope", Message: "scope needs correction", CorrectionGuidance: "correct the chunk scope"}, nil - } - return contracts.ValidationResult{Approved: true}, nil - }}, - }} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if len(output.Rejected) != 0 || chunker.calls != 2 || validatorCalls != 2 { - t.Fatalf("output = %#v chunker calls = %d validator calls = %d", output.Rejected, chunker.calls, validatorCalls) - } - if got := string(chunker.correction.AssistantResponse); got != "initial chunk response" { - t.Fatalf("correction response = %q", got) - } -} - -func TestRunnerDoesNotPublishValidationIncompleteChunkPlan(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.ChunkValidationPolicy.ValidatorFailure = ValidatorFailureWarnContinue - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan} - prepared.chunkValidators.validators = []preparedValidator{{ - resolved: ResolvedValidator{Binding: Binding("unavailable"), Target: ValidatorTargetChunk}, - chunk: &countingChunkValidator{err: errors.New("validator unavailable")}, - }} - store := &recordingChunkPlanStore{decision: ChunkPlanDecision{Status: ChunkPlanMissing}} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if output.ChunkPlan == nil || output.ChunkPlan.ValidationStatus != "incomplete" || output.ChunkPlan.PublicationStatus != "not_published" || store.saves != 0 { - t.Fatalf("chunk summary = %#v saves = %d", output.ChunkPlan, store.saves) - } -} - -func TestRunnerRegeneratesValidationIncompleteChunkPlanHit(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.ChunkValidationPolicy.ValidatorFailure = ValidatorFailureWarnContinue - calls := 0 - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls} - validatorCalls := 0 - prepared.chunkValidators.validators = []preparedValidator{{ - resolved: ResolvedValidator{Binding: Binding("cache-then-generated"), Target: ValidatorTargetChunk}, - chunk: chunkValidationFunc{name: "cache-then-generated", validate: func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { - validatorCalls++ - if validatorCalls == 1 { - return contracts.ValidationResult{}, errors.New("cached candidate could not be validated") - } - return contracts.ValidationResult{Approved: true}, nil - }}, - }} - record := chunkPlanRecord(t, prepared, plan) - record.Diagnostics = []contracts.ProducerDiagnostic{producerDiagnostic("stored", "discarded stored diagnostic")} - store := &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}} - debug := newCapturedDebugRecorder() - - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store, Debug: debug}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if calls != 1 || validatorCalls != 2 || store.saves != 1 { - t.Fatalf("calls = producer %d validator %d saves %d, want 1 2 1", calls, validatorCalls, store.saves) - } - if output.ChunkPlan == nil || output.ChunkPlan.Action != "generated" || output.ChunkPlan.LookupStatus != "invalid" || output.ChunkPlan.ValidationStatus != "approved" { - t.Fatalf("chunk plan summary = %#v", output.ChunkPlan) - } - if len(output.Diagnostics.Groups) != 0 { - t.Fatalf("diagnostics = %#v, want discarded cache diagnostics omitted", output.Diagnostics) - } - assertAttemptEnvelopeSequence(t, debug, "chunk", 1) -} - -func TestRunnerKeepsStoredPlanWhenCacheAndGeneratedValidationAreIncomplete(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.ChunkValidationPolicy.ValidatorFailure = ValidatorFailureWarnContinue - calls := 0 - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls} - validator := &countingChunkValidator{err: errors.New("validator unavailable")} - prepared.chunkValidators.validators = []preparedValidator{{resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator}} - record := chunkPlanRecord(t, prepared, plan) - record.Diagnostics = []contracts.ProducerDiagnostic{producerDiagnostic("stored", "discarded stored diagnostic")} - store := &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}} - - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if calls != 1 || validator.calls != 2 || store.saves != 0 { - t.Fatalf("calls = producer %d validator %d saves %d, want 1 2 0", calls, validator.calls, store.saves) - } - if output.ChunkPlan == nil || output.ChunkPlan.Action != "generated" || output.ChunkPlan.LookupStatus != "invalid" || output.ChunkPlan.ValidationStatus != "incomplete" { - t.Fatalf("chunk plan summary = %#v", output.ChunkPlan) - } - if len(output.Diagnostics.Groups) != 1 || output.Diagnostics.Groups[0].ReasonCode != "validator_execution_incomplete" { - t.Fatalf("diagnostics = %#v, want only generated incomplete diagnostic", output.Diagnostics) - } - if !reflect.DeepEqual(store.record, record) { - t.Fatal("discarded incomplete candidates mutated the stored record") - } -} - -func TestRunnerFailsOnValidationIncompleteChunkPlanHitUnderFailRun(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - calls := 0 - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls} - validator := &countingChunkValidator{err: errors.New("validator unavailable")} - prepared.chunkValidators.validators = []preparedValidator{{resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator}} - store := &recordingChunkPlanStore{record: chunkPlanRecord(t, prepared, plan), decision: ChunkPlanDecision{Status: ChunkPlanHit}} - - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if err == nil || !strings.Contains(err.Error(), "validator unavailable") { - t.Fatalf("Run() error = %v, want cached validation failure", err) - } - if calls != 0 || validator.calls != 1 || store.saves != 0 { - t.Fatalf("calls = producer %d validator %d saves %d, want 0 1 0", calls, validator.calls, store.saves) - } - if output.ChunkPlan == nil || output.ChunkPlan.ValidationStatus != "error" { - t.Fatalf("chunk plan summary = %#v", output.ChunkPlan) - } -} - -func TestRunnerRetainsChunkMapAfterLaneRejection(t *testing.T) { - prepared, _ := preparedTerminalDebugPipeline(t) - encoder := &capturingChunkMapOutput{} - prepared.output = encoder - prepared.Steps[0].lanes[0].mergeValidators.validators = []preparedValidator{{ - resolved: ResolvedValidator{Binding: Binding("reject/lane"), Target: ValidatorTargetTyped, ArtifactKind: "test/notes"}, - typedValidate: func(context.Context, any, typedValidationTarget) (contracts.ValidationResult, error) { - return contracts.ValidationResult{Approved: false, ReasonCode: "rejected", Message: "not accepted", CorrectionGuidance: "return an acceptable candidate"}, nil - }, - }} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")}) - if err != nil { - t.Fatalf("Run() error = %v", err) - } - if len(output.Rejected) != 1 || len(encoder.requests) != 1 || encoder.requests[0].ChunkMap == nil { - t.Fatalf("output = %#v requests = %#v, want lane rejection with accepted chunk map", output.Rejected, encoder.requests) - } -} - -func TestRunnerChunkMapRequestDoesNotAliasStoredPlan(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - encoder := &capturingChunkMapOutput{} - prepared.output = encoder - record := chunkPlanRecord(t, prepared, plan) - record.Plan.Annotations = source.ChunkAnnotations{"dnd/scenes": json.RawMessage(`{"title":"Opening"}`)} - store := &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}} - if _, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}); err != nil { - t.Fatalf("Run() error = %v", err) - } - store.record.Plan.Annotations["dnd/scenes"][0] = '[' - value, err := chunkmap.New().Decode(encoder.requests[0].ChunkMap.Content) - if err != nil { - t.Fatalf("decode captured chunk map after store mutation: %v", err) - } - if string(value.PlanAnnotations["dnd/scenes"]) != `{"title":"Opening"}` { - t.Fatalf("captured chunk map aliases stored plan: %s", value.PlanAnnotations["dnd/scenes"]) - } -} - -func TestRunnerChunkPlanManifestRetainsCandidateOnRejection(t *testing.T) { - prepared, _ := preparedTerminalDebugPipeline(t) - validator := &countingChunkValidator{result: contracts.ValidationResult{Approved: false, ReasonCode: "policy", Message: "no", CorrectionGuidance: "return a policy-compliant chunk plan"}} - prepared.chunkValidators.validators = []preparedValidator{{resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator}} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheRefresh, ChunkPlans: &recordingChunkPlanStore{}}) - if err != nil { - t.Fatal(err) - } - if output.Manifest.ChunkPlan.Action != "" || output.Manifest.ChunkPlan.PlanDigest != "" || output.ChunkPlan.ValidationStatus != "rejected" || output.ChunkPlan.PublicationStatus != "not_published" { - t.Fatalf("manifest = %#v summary = %#v; rejected output must not retain a usable chunk candidate", output.Manifest.ChunkPlan, output.ChunkPlan) - } -} - -func TestRunnerValidatesChunkPlanPolicyInputs(t *testing.T) { - for _, tc := range []struct { - name string - mode ChunkCacheMode - want string - }{ - {name: "auto requires store", mode: ChunkCacheAuto, want: "store is required"}, - {name: "refresh requires store", mode: ChunkCacheRefresh, want: "store is required"}, - {name: "invalid mode", mode: "sometimes", want: "not supported"}, - } { - t.Run(tc.name, func(t *testing.T) { - prepared, _ := preparedTerminalDebugPipeline(t) - _, err := New().Run(context.Background(), RunInput{Prepared: prepared, ChunkCacheMode: tc.mode}) - if err == nil || !strings.Contains(err.Error(), tc.want) { - t.Fatalf("Run() error = %v, want %q", err, tc.want) - } - }) - } -} - -func TestRunnerChunkPlanStoreErrorsAreFrameworkErrors(t *testing.T) { - for _, tc := range []struct { - name string - mode ChunkCacheMode - decision ChunkPlanDecision - loadErr error - saveErr error - wantError string - wantCalls int - }{ - {name: "load", mode: ChunkCacheAuto, loadErr: errors.New("read failed"), wantError: "load chunk plan", wantCalls: 0}, - {name: "save", mode: ChunkCacheRefresh, saveErr: errors.New("write failed"), wantError: "save chunk plan", wantCalls: 1}, - } { - t.Run(tc.name, func(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - calls := 0 - llmCalls := 0 - prepared.chunker = llmCountingChunker{terminalChunker: terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls}, llmCalls: &llmCalls} - store := &recordingChunkPlanStore{decision: tc.decision, loadErr: tc.loadErr, saveErr: tc.saveErr} - _, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: tc.mode, ChunkPlans: store}) - if err == nil || !strings.Contains(err.Error(), tc.wantError) || calls != tc.wantCalls { - t.Fatalf("Run() error = %v, module calls = %d, want %q and %d", err, calls, tc.wantError, tc.wantCalls) - } - }) - } -} - -func TestRunnerRegeneratesStructurallyInvalidHit(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - calls := 0 - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls} - invalid := chunkPlanRecord(t, prepared, plan) - invalid.Plan.Ranges[0].StartUnitID = 999 - store := &recordingChunkPlanStore{record: invalid, decision: ChunkPlanDecision{Status: ChunkPlanHit}} - if _, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}); err != nil { - t.Fatal(err) - } - if calls != 1 || store.loads != 1 || store.saves != 1 { - t.Fatalf("calls = module %d load %d save %d, want 1 1 1", calls, store.loads, store.saves) - } -} - -func TestRunnerReusesAnnotationsFromDifferentChunkerAsOptionalData(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - plan.Annotations = source.ChunkAnnotations{"test/chunker": json.RawMessage(`{"label":"fixture"}`)} - plan.Ranges[0].Annotations = source.ChunkAnnotations{"test/chunker": json.RawMessage(`{"category":"sample"}`)} - record := chunkPlanRecord(t, prepared, plan) - record.Producer.ChunkModule = "chunk/producer" - store := &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if err != nil { - t.Fatal(err) - } - if output.Manifest.ChunkPlan.ProducerModule != "chunk/producer" || output.Manifest.ChunkPlan.Action != "reused" { - t.Fatalf("different-chunker annotation plan was not reused: %#v", output.Manifest.ChunkPlan) - } -} - -func TestRunnerRetriesBeforePublishingAcceptedPlan(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.Chunk.Retries = 1 - chunker := &retryingChunker{key: prepared.resolved.Chunk.Module, plan: plan} - prepared.chunker = chunker - store := &recordingChunkPlanStore{decision: ChunkPlanDecision{Status: ChunkPlanMissing}} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if err != nil { - t.Fatal(err) - } - if chunker.calls != 2 || store.saves != 1 { - t.Fatalf("module calls = %d saves = %d, want 2 and 1", chunker.calls, store.saves) - } - if len(output.Diagnostics.Groups) != 1 || output.Diagnostics.Groups[0].Samples[0].Scope != "accepted" || len(store.saved.Diagnostics) != 1 || store.saved.Diagnostics[0].Samples[0].Scope != "accepted" { - t.Fatalf("output diagnostics = %#v stored diagnostics = %#v", output.Diagnostics, store.saved.Diagnostics) - } -} - -func TestRunnerAutoHitValidatesOnceWithoutRegenerationOrMutation(t *testing.T) { - tests := []struct { - name string - result contracts.ValidationResult - validatorErr error - wantError string - wantReject bool - }{ - {name: "diagnostic", result: contracts.ValidationResult{Approved: true, Diagnostics: []contracts.ProducerDiagnostic{producerDiagnostic("current", "current diagnostic")}}}, - {name: "rejection", result: contracts.ValidationResult{Approved: false, ReasonCode: "rejected", Message: "rejected hit", CorrectionGuidance: "return an acceptable chunk plan"}, wantReject: true}, - {name: "error", validatorErr: errors.New("validator failed"), wantError: "validator failed"}, - } - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - calls := 0 - llmCalls := 0 - prepared.chunker = llmCountingChunker{terminalChunker: terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls}, llmCalls: &llmCalls} - validator := &countingChunkValidator{result: tc.result, err: tc.validatorErr} - prepared.chunkValidators.validators = []preparedValidator{{resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator}} - record := chunkPlanRecord(t, prepared, plan) - record.Diagnostics = []contracts.ProducerDiagnostic{producerDiagnostic("stored", "stored diagnostic")} - store := &recordingChunkPlanStore{record: record, decision: ChunkPlanDecision{Status: ChunkPlanHit}} - debug := newCapturedDebugRecorder() - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store, Debug: debug}) - if tc.wantError != "" { - if err == nil || !strings.Contains(err.Error(), tc.wantError) { - t.Fatalf("Run() error = %v, want %q", err, tc.wantError) - } - } else if err != nil { - t.Fatalf("Run() error = %v", err) - } - wantProducerCalls := 0 - if tc.wantReject { - wantProducerCalls = 1 - } - if validator.calls != 1+wantProducerCalls || calls != wantProducerCalls || llmCalls != wantProducerCalls || store.loads != 1 || store.saves != 0 { - t.Fatalf("calls = validator %d module %d llm %d load %d save %d", validator.calls, calls, llmCalls, store.loads, store.saves) - } - if tc.wantReject { - assertAttemptEnvelopeSequence(t, debug, "chunk", 1) - } else { - assertAttemptEnvelopeSequence(t, debug, "chunk") - } - if tc.wantError == "" { - encoded := string(debug.json["chunk/output.json"]) - if tc.wantReject { - if !strings.Contains(encoded, `"status":"invalid"`) || strings.Contains(encoded, `"plan":`) { - t.Fatalf("rejected cache debug = %s", encoded) - } - } else if !strings.Contains(encoded, `"status":"hit"`) || !strings.Contains(encoded, `"plan":`) || !strings.Contains(encoded, `"materialized_chunks":`) { - t.Fatalf("chunk hit debug = %s", encoded) - } - } - if tc.wantReject && (len(output.Rejected) != 1 || output.Rejected[0].ReasonCode != "rejected") { - t.Fatalf("rejected = %#v", output.Rejected) - } - if tc.wantError == "" && !tc.wantReject && len(output.Diagnostics.Groups) != 1+len(tc.result.Diagnostics) { - t.Fatalf("diagnostics = %#v, want stored diagnostic once plus current diagnostics", output.Diagnostics) - } - }) - } -} - -func TestRunnerPublishesOnlyAcceptedGeneratedPlans(t *testing.T) { - for _, tc := range []struct { - name string - moduleErr error - validator contracts.ValidationResult - cancel bool - wantCalls int - wantReject bool - }{ - {name: "module error", moduleErr: errors.New("generation failed"), wantCalls: 2}, - {name: "validator rejection", validator: contracts.ValidationResult{Approved: false, ReasonCode: "rejected", Message: "rejected generated plan", CorrectionGuidance: "return an acceptable chunk plan"}, wantCalls: 1, wantReject: true}, - {name: "cancellation", cancel: true}, - } { - t.Run(tc.name, func(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.Chunk.Retries = 1 - calls := 0 - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, calls: &calls, err: tc.moduleErr} - if tc.wantReject { - validator := &countingChunkValidator{result: tc.validator} - prepared.chunkValidators.validators = []preparedValidator{{resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator}} - } - ctx := context.Background() - if tc.cancel { - cancelled, cancel := context.WithCancel(ctx) - cancel() - ctx = cancelled - } - store := &recordingChunkPlanStore{decision: ChunkPlanDecision{Status: ChunkPlanInvalid}} - output, err := New().Run(ctx, RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheAuto, ChunkPlans: store}) - if tc.wantReject { - if err != nil || len(output.Rejected) != 1 { - t.Fatalf("Run() error = %v rejected = %#v", err, output.Rejected) - } - } else if err == nil { - t.Fatal("Run() error = nil") - } - if calls != tc.wantCalls || store.saves != 0 { - t.Fatalf("module calls = %d, saves = %d; want %d, 0", calls, store.saves, tc.wantCalls) - } - }) - } -} - -func TestRunnerStoresProducerProvenanceAndDiagnostics(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.Chunk.LLMProfile = "chunk-profile" - prepared.resolved.ChunkExecutionClass = contracts.ExecutionClassLLMBacked - prepared.resolved.ChunkReferences = ResolvedReferenceTarget{ - Stage: StageChunk, - ReferenceSet: contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ - "guide": {Items: []contracts.ReferenceItem{{SlotName: "guide", Digest: "sha256:guide", Origin: contracts.ReferenceOrigin{Type: "file", URI: "file:///guide.txt"}, Content: []byte("sensitive")}}}, - }}, - } - prepared.chunker = manifestChunker{terminalChunker: terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan, diagnostics: []contracts.ProducerDiagnostic{producerDiagnostic("producer", "producer diagnostic")}}, metadata: map[string]any{"prompt_id": "chunk/prompt"}} - validator := &countingChunkValidator{result: contracts.ValidationResult{Approved: true, Diagnostics: []contracts.ProducerDiagnostic{producerDiagnostic("validator", "validator diagnostic")}}} - prepared.chunkValidators.validators = []preparedValidator{{resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator}} - store := &recordingChunkPlanStore{} - if _, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheRefresh, ChunkPlans: store}); err != nil { - t.Fatal(err) - } - producer := store.saved.Producer - if producer.InputModule != prepared.input.Key() || producer.ChunkModule != prepared.chunker.Key() || producer.LLMProfile != "chunk-profile" || producer.Metadata["prompt_id"] != "chunk/prompt" { - t.Fatalf("producer = %#v", producer) - } - if len(producer.References) != 1 || producer.References[0].Digest != "sha256:guide" { - t.Fatalf("producer references = %#v", producer.References) - } - if len(store.saved.Diagnostics) != 1 || store.saved.Diagnostics[0].Samples[0].Scope != "producer" { - t.Fatalf("stored diagnostics = %#v, want only producer diagnostic", store.saved.Diagnostics) - } -} - -func TestRunnerRejectsUncloneableModuleManifestMetadata(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - cyclic := make(map[string]any) - cyclic["self"] = cyclic - prepared.chunker = manifestChunker{ - terminalChunker: terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan}, - metadata: map[string]any{"cyclic": cyclic}, - } - _, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")}) - if err == nil || !strings.Contains(err.Error(), `clone manifest metadata for module "chunker": metadata.cyclic.self contains a cycle`) { - t.Fatalf("Run() error = %v, want contextual module metadata clone failure", err) - } -} - -func TestRunnerOmitsProducerProfileForDeterministicChunker(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.Chunk.LLMProfile = "configured-but-unused" - prepared.resolved.ChunkExecutionClass = contracts.ExecutionClassDeterministic - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan} - store := &recordingChunkPlanStore{} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheRefresh, ChunkPlans: store}) - if err != nil { - t.Fatal(err) - } - if store.saved.Producer.LLMProfile != "" || output.Manifest.ChunkPlan.ProducerLLMProfile != "" { - t.Fatalf("deterministic producer profile = stored %q manifest %q", store.saved.Producer.LLMProfile, output.Manifest.ChunkPlan.ProducerLLMProfile) - } -} - -func TestRunnerDoesNotInventProducerProfileForLLMChunker(t *testing.T) { - prepared, plan := preparedTerminalDebugPipeline(t) - prepared.resolved.ChunkExecutionClass = contracts.ExecutionClassLLMBacked - prepared.resolved.Chunk.LLMProfile = "" - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan} - store := &recordingChunkPlanStore{} - - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ChunkCacheMode: ChunkCacheRefresh, ChunkPlans: store}) - if err != nil { - t.Fatal(err) - } - if store.saved.Producer.LLMProfile != "" || output.Manifest.ChunkPlan.ProducerLLMProfile != "" { - t.Fatalf("LLM producer profile = stored %q manifest %q, want empty", store.saved.Producer.LLMProfile, output.Manifest.ChunkPlan.ProducerLLMProfile) - } -} - -func TestRunnerRefreshChangesDownstreamChunkFingerprint(t *testing.T) { - doc := typedTestDocumentWithUnits(2) - prepared := preparedConcurrentPipeline(t, 1) - prepared.Steps[0].lanes = prepared.Steps[0].lanes[:1] - prepared.resolved.Steps[0].ArtifactLanes = prepared.resolved.Steps[0].ArtifactLanes[:1] - prepared.Steps[0].ArtifactLanes = prepared.Steps[0].ArtifactLanes[:1] - prepared.input = &typedTestInput{key: prepared.resolved.Input.Module, doc: doc} - - run := func(plan source.ChunkPlan) []CheckpointFingerprint { - prepared.chunker = terminalChunker{key: prepared.resolved.Chunk.Module, plan: plan} - loader := &dependencyLoader{CheckpointLoader: NoopCheckpointLoader()} - if _, err := New().Run(context.Background(), RunInput{Prepared: prepared, ChunkCacheMode: ChunkCacheRefresh, ChunkPlans: &recordingChunkPlanStore{}, Checkpoint: loader}); err != nil { + input.Prepared.output = encoder + input.RawInput = []byte("input") + input.Cache = store + for range 2 { + if _, err := New().Run(context.Background(), input); err != nil { t.Fatal(err) } - return loader.extractDependencies } - separate := typedTestPlan(doc) - combined := source.ChunkPlan{SourceDigest: doc.Digest, Ranges: []source.ChunkRange{{StartUnitID: 1, EndUnitID: 2}}} - if first, second := run(separate), run(combined); reflect.DeepEqual(first, second) { - t.Fatalf("downstream fingerprints did not change: %#v", first) + if calls != 1 || assessments != 1 || len(encoder.requests) != 2 { + t.Fatalf("calls=%d assessments=%d output requests=%d", calls, assessments, len(encoder.requests)) + } + for _, request := range encoder.requests { + artifact := request.ChunkMap + if artifact == nil || artifact.Kind != chunkmap.ArtifactKind || artifact.Schema.ID != chunkmap.SchemaID || artifact.MediaType != chunkmap.MediaType { + t.Fatalf("chunk map artifact=%#v", artifact) + } + value, err := chunkmap.New().Decode(artifact.Content) + if err != nil { + t.Fatal(err) + } + wantProducer := chunkmap.Producer{InputModule: input.Prepared.input.Key(), ChunkModule: "cached-plan"} + if value.RequestedChunker != "cached-plan" || value.Producer != wantProducer || len(value.Chunks) != 1 { + t.Fatalf("chunk map=%#v", value) + } } } -func chunkPlanRecord(t *testing.T, prepared *PreparedPipeline, plan source.ChunkPlan) ChunkPlanRecord { - t.Helper() - digest, err := source.DigestChunkPlan(plan) - if err != nil { - t.Fatal(err) - } - return ChunkPlanRecord{ - SchemaVersion: ChunkPlanSchemaVersion, - SourceDigest: plan.SourceDigest, - PlanDigest: digest, - Plan: source.CloneChunkPlan(plan), - Producer: ChunkPlanProducer{InputModule: prepared.input.Key(), ChunkModule: prepared.chunker.Key()}, - CreatedAt: time.Now().UTC(), +func TestRunnerDoesNotPublishRejectedChunkPlan(t *testing.T) { + engine := nativeProducerEngine(t, producerClientFunc(func(context.Context, promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { + return planResponse(t, typedTestPlan(typedTestDocument())), nil + })) + input := planCacheRunInput(t, engine, func(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { + return contracts.ValidationResult{ReasonCode: "partition", CorrectionGuidance: "Choose a valid partition."}, nil + }) + input.Prepared.resolved.ChunkControls.MaxAdditionalTurns = 0 + encoder := &capturingChunkMapOutput{} + input.Prepared.output = encoder + input.RawInput = []byte("input") + _, err := New().Run(context.Background(), input) + if err == nil || len(encoder.requests) != 0 { + t.Fatalf("rejected plan error=%v output requests=%d", err, len(encoder.requests)) + } +} + +func TestDeterministicChunkMapDoesNotInventModelProvenance(t *testing.T) { + catalog := typedResolutionCatalog(t, completeTypedCatalogOptions()) + prepared := prepareRunnerProfile(t, catalog, typedResolutionProfile(), nil) + prepared.resolved.Chunk.LLMProfile = "configured-but-not-used" + encoder := &capturingChunkMapOutput{} + prepared.output = encoder + if _, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")}); err != nil { + t.Fatal(err) + } + if len(encoder.requests) != 1 || encoder.requests[0].ChunkMap == nil { + t.Fatal("missing chunk map") + } + value, err := chunkmap.New().Decode(encoder.requests[0].ChunkMap.Content) + if err != nil || value.Producer.LLMProfile != "" { + t.Fatalf("model provenance=%#v %v", value.Producer, err) } } diff --git a/internal/framework/pipeline/runner_concurrent.go b/internal/framework/pipeline/runner_concurrent.go index 157cec22..136e245c 100644 --- a/internal/framework/pipeline/runner_concurrent.go +++ b/internal/framework/pipeline/runner_concurrent.go @@ -19,40 +19,20 @@ type laneExtractState struct { fallbackCount int index int prepared preparedLaneExecutor - deps []CheckpointFingerprint - decision CheckpointDecision reuseEligible bool values []erasedExtractArtifact - serialized []CheckpointArtifact diagnostics []contracts.DiagnosticGroup - rejected []contracts.RejectedOutput results map[int]extractJobResult remaining int failed bool - terminal bool - output RunOutput } type finalizedExtractResults struct { accepted []erasedExtractArtifact - serialized []CheckpointArtifact diagnostics []contracts.DiagnosticGroup - rejected []contracts.RejectedOutput - decision CheckpointDecision reuseEligible bool } -func loadExtract(loader CheckpointLoader, stepID, laneID, moduleKey string, deps []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) { - if stepAware, ok := loader.(StepCheckpointLoader); ok { - return stepAware.ExtractForStep(stepID, laneID, moduleKey, deps) - } - return loader.Extract(laneID, moduleKey, deps) -} - -func recordExtract(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, outputs []CheckpointArtifact, rejected []contracts.RejectedOutput) error { - return checkpointExtractSucceeded(recorder, stepID, laneID, moduleKey, deps, outputs, rejected) -} - type extractJob struct { lane *laneExtractState chunk source.Chunk @@ -62,9 +42,7 @@ type extractJobResult struct { laneIndex int chunkIndex int value erasedExtractArtifact - serialized CheckpointArtifact diagnostics []contracts.DiagnosticGroup - rejected *contracts.RejectedOutput outcome contracts.ProducerOutcome err error } @@ -82,17 +60,14 @@ type orderedRunError struct { err error } -func (r *Runner) runLanes(parent context.Context, input RunInput, step PreparedPipelineStep, checkpoints CheckpointRecorder, loader CheckpointLoader, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, chunks []source.Chunk) (RunOutput, error) { +func (r *Runner) runLanes(parent context.Context, input RunInput, step PreparedPipelineStep, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, chunks []source.Chunk) (RunOutput, error) { output := RunOutput{Manifest: manifestFromPipeline(input)} - states, err := initializeLaneStates(input, step, checkpoints, loader, doc, chunks, &output) + states, err := initializeLaneStates(input, step, chunks, &output) if err != nil { - if mergeErr := mergeTerminalLaneStates(&output, states); mergeErr != nil { - return output, errors.Join(err, mergeErr) - } return output, err } completedOutputs, runErrors := r.runLaneEngine(parent, laneEngineConfig{ - input: input, checkpoints: checkpoints, loader: loader, doc: doc, + input: input, doc: doc, sourceInput: sourceInput, sessionID: sessionID, chunks: chunks, states: states, }) if err := mergeCompletedLanes(&output, completedOutputs); err != nil { @@ -104,46 +79,22 @@ func (r *Runner) runLanes(parent context.Context, input RunInput, step PreparedP return output, nil } -func initializeLaneStates(input RunInput, step PreparedPipelineStep, checkpoints CheckpointRecorder, loader CheckpointLoader, doc *source.SourceDocument, chunks []source.Chunk, output *RunOutput) ([]*laneExtractState, error) { +func initializeLaneStates(input RunInput, step PreparedPipelineStep, chunks []source.Chunk, output *RunOutput) ([]*laneExtractState, error) { states := make([]*laneExtractState, len(step.lanes)) for i, prepared := range step.lanes { if prepared.typed == nil { - return states, fmt.Errorf("typed lane %q executor is not prepared", prepared.resolved.ID) + return nil, fmt.Errorf("typed lane %q executor is not prepared", prepared.resolved.ID) } if err := setTypedLaneManifestMetadata(output, prepared.resolved.ID, prepared.typed.extractor, prepared.typed.merger, prepared.typed.normalizer); err != nil { - return states, err + return nil, err } - if input.CheckpointPolicy.requiresReusable(input.stepID, prepared.resolved.ID) && !input.CheckpointPolicy.forced(input.stepID, prepared.resolved.ID) { - if input.reuseIneligible || !laneReferencesReuseEligible(input, prepared.resolved) { - return states, fmt.Errorf("required reusable checkpoint unavailable for step %q lane %q: generated input lineage is validation-incomplete", input.stepID, prepared.resolved.ID) - } - state, err := hydrateRequiredLane(input, loader, doc, i, prepared) - states[i] = state - if err != nil { - return states, err - } - continue - } - state, err := prepareLaneExtract(input, loader, doc, chunks, i, prepared, output) - if err != nil { - return states, err - } - if !state.decision.Reused && state.reuseEligible { - if err := checkpointExtractRunning(checkpoints, input.stepID, prepared.resolved.ID, prepared.resolved.Extract.Module, state.deps); err != nil { - return states, fmt.Errorf("write extract checkpoint for lane %q: %w", prepared.resolved.ID, err) - } - } else if err := finalizeLaneExtract(checkpoints, input.stepID, state); err != nil { - return states, err - } - states[i] = state + states[i] = &laneExtractState{index: i, prepared: prepared, reuseEligible: !input.reuseIneligible && referenceTargetReuseEligible(input, prepared.resolved.ExtractReferences), remaining: len(chunks), results: make(map[int]extractJobResult, len(chunks))} } return states, nil } type laneEngineConfig struct { input RunInput - checkpoints CheckpointRecorder - loader CheckpointLoader doc *source.SourceDocument sourceInput contracts.LLMInputMaterial sessionID string @@ -200,13 +151,6 @@ func newLaneEngine(r *Runner, parent context.Context, config laneEngineConfig) * func (e *laneEngine) run() ([]RunOutput, []orderedRunError) { defer e.cancel() - for _, state := range e.states { - if state.terminal { - e.completedOutputs[state.index] = state.output - } else if state.decision.Reused { - e.pending = append(e.pending, state) - } - } e.startWorkers() e.collect() close(e.jobs) @@ -229,7 +173,7 @@ func (e *laneEngine) startWorkers() { if err := e.ctx.Err(); err != nil { completion.err = err } else { - completion.output, completion.err = e.runner.continueLane(e.ctx, e.input, e.checkpoints, e.loader, e.doc, e.sourceInput, e.sessionID, e.chunks, job.lane) + completion.output, completion.err = e.runner.continueLane(e.ctx, e.input, e.doc, e.sourceInput, e.sessionID, e.chunks, job.lane) } e.results <- laneJobResult{completion: &completion} } @@ -244,12 +188,9 @@ func (e *laneEngine) nextJob() (laneJob, bool) { if len(e.pending) > 0 { return laneJob{lane: e.pending[0]}, true } - for e.nextExtract < len(e.chunks)*len(e.states) { + if e.nextExtract < len(e.chunks)*len(e.states) { state := e.states[e.nextExtract%len(e.states)] - if !state.terminal && !state.decision.Reused { - return laneJob{lane: state, chunk: &e.chunks[e.nextExtract/len(e.states)]}, true - } - e.nextExtract++ + return laneJob{lane: state, chunk: &e.chunks[e.nextExtract/len(e.states)]}, true } return laneJob{}, false } @@ -303,9 +244,6 @@ func (e *laneEngine) handleExtractResult(result extractJobResult) { if result.err != nil { state.failed = true e.runErrors = append(e.runErrors, orderedRunError{stage: 0, lane: state.index, chunk: result.chunkIndex, err: result.err}) - if state.reuseEligible { - _ = checkpointExtractFailed(e.checkpoints, e.input.stepID, state.prepared.resolved.ID, state.prepared.resolved.Extract.Module, state.deps, result.err) - } e.cancel() } else { state.results[result.chunkIndex] = result @@ -313,12 +251,7 @@ func (e *laneEngine) handleExtractResult(result extractJobResult) { if state.remaining != 0 || state.failed || e.ctx.Err() != nil { return } - if err := finalizeLaneExtract(e.checkpoints, e.input.stepID, state); err != nil { - state.failed = true - e.runErrors = append(e.runErrors, orderedRunError{stage: 0, lane: state.index, chunk: len(e.chunks), err: err}) - e.cancel() - return - } + finalizeLaneExtract(state) e.pending = append(e.pending, state) } @@ -330,52 +263,6 @@ func (e *laneEngine) handleCompletion(completion laneCompletion) { } } -func hydrateRequiredLane(input RunInput, loader CheckpointLoader, doc *source.SourceDocument, index int, prepared preparedLaneExecutor) (*laneExtractState, error) { - lane, typed := prepared.resolved, prepared.typed - local := RunOutput{Manifest: manifestFromPipeline(input)} - checkpoint, decision := loader.AcceptedNormalize(input.stepID, lane.ID, lane.Normalize.Module) - if decision.Reused { - decision = checkpointDecision(CheckpointDecisionReused, CheckpointReasonAcceptedArtifactReused) - if checkpoint.Output.LaneID != lane.ID || checkpoint.Output.ModuleKey != lane.Normalize.Module || checkpoint.Output.SourceID != doc.ID { - decision = checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonArtifactPayloadInvalid) - } - } - resolution, err := resolveCheckpointDecision(&local, loader, input.CheckpointPolicy, StageNormalize, input.stepID, lane.ID, lane.Normalize.Module, decision, typed.codec, []CheckpointArtifact{checkpoint.Output}) - decision = resolution.decision - state := &laneExtractState{index: index, prepared: prepared, decision: decision, reuseEligible: true, terminal: true, output: local} - if err != nil { - return state, err - } - hydrated := resolution.artifacts[0] - diagnostics, diagnosticErr := promoteCheckpointDiagnostics(hydrated.Diagnostics, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageNormalize, StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Normalize.Module}, nil) - if diagnosticErr != nil { - return state, fmt.Errorf("promote reused accepted diagnostics: %w", diagnosticErr) - } - appendDiagnosticGroups(&local, diagnostics) - local.NormalizeOutputs = append(local.NormalizeOutputs, contracts.SerializedOutput{ - StepID: input.stepID, - LaneID: lane.ID, - NormalizerKey: lane.Normalize.Module, - SourceID: doc.ID, - Artifact: contracts.CloneSerializedArtifact(hydrated.Artifact), - }) - local.normalizeReuseEligibility = map[generatedOutputKey]bool{generatedOutputKeyFor(input.stepID, lane.ID): true} - state.output = local - return state, nil -} - -func mergeTerminalLaneStates(output *RunOutput, states []*laneExtractState) error { - for _, state := range states { - if state == nil || !state.terminal { - continue - } - if err := mergeLaneOutput(output, state.output); err != nil { - return err - } - } - return nil -} - func mergeCompletedLanes(output *RunOutput, completedOutputs []RunOutput) error { for i := range completedOutputs { if err := mergeLaneOutput(output, completedOutputs[i]); err != nil { @@ -385,49 +272,6 @@ func mergeCompletedLanes(output *RunOutput, completedOutputs []RunOutput) error return nil } -func prepareLaneExtract(input RunInput, loader CheckpointLoader, doc *source.SourceDocument, chunks []source.Chunk, index int, prepared preparedLaneExecutor, output *RunOutput) (*laneExtractState, error) { - lane, typed := prepared.resolved, prepared.typed - digest, err := joinedChunkDigest(chunks) - if err != nil { - return nil, fmt.Errorf("digest chunks for lane %q: %w", lane.ID, err) - } - extractReferences := operationReferenceSet(input, lane.ExtractReferences) - deps := append(digestFingerprints("chunks", digest), generatedReferenceDependencies(extractReferences)...) - state := &laneExtractState{index: index, prepared: prepared, deps: normalizeCheckpointFingerprints(deps), reuseEligible: !input.reuseIneligible && referenceTargetReuseEligible(input, lane.ExtractReferences), remaining: len(chunks), results: make(map[int]extractJobResult, len(chunks))} - if !state.reuseEligible { - state.decision = checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonValidationIncompleteLineage) - recordCheckpointEvent(output, loader, string(StageExtract), input.stepID, lane.ID, lane.Extract.Module, state.decision) - return state, nil - } - cp, decision := loadExtract(loader, input.stepID, lane.ID, lane.Extract.Module, state.deps) - resolution, err := resolveCheckpointDecision(output, loader, input.CheckpointPolicy, StageExtract, input.stepID, lane.ID, lane.Extract.Module, decision, typed.codec, cp.Outputs) - if err != nil { - return nil, err - } - decision = resolution.decision - state.decision = decision - if decision.Reused { - state.remaining = 0 - for i, stored := range resolution.artifacts { - value := resolution.values[i] - artifact := erasedExtractArtifact{LaneID: lane.ID, ExtractorKey: lane.Extract.Module, SourceID: doc.ID, ChunkID: stored.ChunkID, ChunkIndex: stored.ChunkIndex, ChunkRef: stored.ChunkRef, Value: value} - if stored.ChunkIndex >= 0 && stored.ChunkIndex < len(chunks) && artifact.ChunkRef == (source.SourceRef{}) { - artifact.ChunkRef = chunks[stored.ChunkIndex].Ref - } - state.values = append(state.values, artifact) - state.serialized = append(state.serialized, cloneCheckpointArtifact(stored)) - chunk := source.Chunk{ID: stored.ChunkID, Index: stored.ChunkIndex} - diagnostics, diagnosticErr := promoteCheckpointDiagnostics(stored.Diagnostics, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageExtract, StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Extract.Module}, &chunk) - if diagnosticErr != nil { - return nil, fmt.Errorf("promote reused extract diagnostics: %w", diagnosticErr) - } - state.diagnostics = append(state.diagnostics, diagnostics...) - } - state.rejected = cloneRejectedOutputs(cp.Rejected) - } - return state, nil -} - func (r *Runner) runExtractJob(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, job extractJob) extractJobResult { state := job.lane lane, typed := state.prepared.resolved, state.prepared.typed @@ -469,24 +313,22 @@ func (r *Runner) runExtractJob(ctx context.Context, input RunInput, doc *source. result.err = fmt.Errorf("accept extract lane %q chunk %q: %w", lane.ID, chunk.ID, err) return result } - stored, err := checkpointArtifact(typed.codec, lane.ID, lane.Extract.Module, doc.ID, value) + stored, err := serializeArtifact(typed.codec, value, false) if err != nil { result.err = fmt.Errorf("encode extract lane %q chunk %q: %w", lane.ID, chunk.ID, err) return result } - stored.ChunkID, stored.ChunkIndex, stored.ChunkRef = chunk.ID, chunk.Index, chunk.Ref result.diagnostics, err = operationDiagnosticGroups(extracted.Diagnostics, cacheDiagnostics, assessment, outcome, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageExtract, StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Extract.Module}, &chunk) if err != nil { result.err = err return result } - result.value = erasedExtractArtifact{LaneID: lane.ID, ExtractorKey: lane.Extract.Module, SourceID: doc.ID, ChunkID: chunk.ID, ChunkIndex: chunk.Index, ChunkRef: chunk.Ref, Value: value} - result.serialized, result.outcome = stored, outcome + result.value = erasedExtractArtifact{LaneID: lane.ID, ExtractorKey: lane.Extract.Module, SourceID: doc.ID, ChunkID: chunk.ID, ChunkIndex: chunk.Index, ChunkRef: chunk.Ref, Value: value, artifact: stored} + result.outcome = outcome return result } -func finalizeLaneExtract(checkpoints CheckpointRecorder, stepID string, state *laneExtractState) error { - lane := state.prepared.resolved +func finalizeLaneExtract(state *laneExtractState) { indexes := make([]int, 0, len(state.results)) for index := range state.results { indexes = append(indexes, index) @@ -494,13 +336,7 @@ func finalizeLaneExtract(checkpoints CheckpointRecorder, stepID string, state *l sort.Ints(indexes) for _, index := range indexes { result := state.results[index] - if result.rejected != nil { - state.rejected = append(state.rejected, *result.rejected) - state.diagnostics = append(state.diagnostics, result.diagnostics...) - continue - } state.values = append(state.values, result.value) - state.serialized = append(state.serialized, result.serialized) state.diagnostics = append(state.diagnostics, result.diagnostics...) if !result.outcome.ReuseEligible { state.reuseEligible = false @@ -509,43 +345,38 @@ func finalizeLaneExtract(checkpoints CheckpointRecorder, stepID string, state *l state.fallbackCount++ } } - sort.SliceStable(state.values, func(i, j int) bool { return state.values[i].ChunkIndex < state.values[j].ChunkIndex }) - sort.SliceStable(state.serialized, func(i, j int) bool { return state.serialized[i].ChunkIndex < state.serialized[j].ChunkIndex }) - sort.SliceStable(state.rejected, func(i, j int) bool { return state.rejected[i].ChunkIndex < state.rejected[j].ChunkIndex }) - if !state.decision.Reused && state.reuseEligible { - if err := recordExtract(checkpoints, stepID, lane.ID, lane.Extract.Module, state.deps, state.serialized, state.rejected); err != nil { - return fmt.Errorf("write extract checkpoint for lane %q: %w", lane.ID, err) - } - } - return nil } -func (r *Runner) continueLane(ctx context.Context, input RunInput, checkpoints CheckpointRecorder, loader CheckpointLoader, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, chunks []source.Chunk, state *laneExtractState) (RunOutput, error) { +func (r *Runner) continueLane(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, chunks []source.Chunk, state *laneExtractState) (RunOutput, error) { lane := state.prepared.resolved local := RunOutput{Manifest: manifestFromPipeline(input), FallbackCount: state.fallbackCount} results := finalizedExtractResults{ accepted: state.values, - serialized: state.serialized, diagnostics: state.diagnostics, - rejected: state.rejected, - decision: state.decision, reuseEligible: state.reuseEligible, } local.diagnosticGroups = append(local.diagnosticGroups, contracts.CloneDiagnosticCollection(contracts.DiagnosticCollection{Groups: results.diagnostics}).Groups...) - local.Rejected = append(local.Rejected, cloneRejectedOutputs(results.rejected)...) - if err := writeDebugTimed(input.Debug, path.Join("extract", fileio.EncodePathComponent(lane.ID), "input.json"), debugTimedEnvelope{Stage: string(StageExtract), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Extract.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"reused": results.decision.Reused, "decision": results.decision, "source": debugSourceDocumentEnvelope(doc), "chunks": debugSourceChunkEnvelopes(chunks), "options": redactSensitiveMap(lane.Extract.Options), "metadata": redactSensitiveMap(input.Metadata)}}); err != nil { + if err := writeDebugTimed(input.Debug, path.Join("extract", fileio.EncodePathComponent(lane.ID), "input.json"), debugTimedEnvelope{Stage: string(StageExtract), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Extract.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"source": debugSourceDocumentEnvelope(doc), "chunks": debugSourceChunkEnvelopes(chunks), "options": redactSensitiveMap(lane.Extract.Options), "metadata": redactSensitiveMap(input.Metadata)}}); err != nil { return local, &laneRunError{stage: StageExtract, err: err} } - if err := writeDebugTimed(input.Debug, path.Join("extract", fileio.EncodePathComponent(lane.ID), "output.json"), debugTimedEnvelope{Stage: string(StageExtract), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Extract.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"reused": results.decision.Reused, "outputs": debugCheckpointArtifacts(results.serialized), "rejected": debugRejectedOutputEnvelopes(results.rejected)}}); err != nil { + if err := writeDebugTimed(input.Debug, path.Join("extract", fileio.EncodePathComponent(lane.ID), "output.json"), debugTimedEnvelope{Stage: string(StageExtract), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Extract.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"outputs": debugExtractArtifacts(results.accepted)}}); err != nil { return local, &laneRunError{stage: StageExtract, err: err} } if len(results.accepted) == 0 { return local, nil } - err := r.continueTypedLane(ctx, input, checkpoints, loader, doc, sourceInput, sessionID, state.prepared, results, &local) + err := r.continueTypedLane(ctx, input, doc, sourceInput, sessionID, state.prepared, results, &local) return local, err } +func debugExtractArtifacts(values []erasedExtractArtifact) []any { + outputs := make([]any, 0, len(values)) + for _, value := range values { + outputs = append(outputs, map[string]any{"chunk_id": value.ChunkID, "chunk_index": value.ChunkIndex, "chunk_ref": value.ChunkRef, "output": debugSerializedOutputEnvelope(contracts.SerializedOutput{LaneID: value.LaneID, SourceID: value.SourceID, Artifact: value.artifact})}) + } + return outputs +} + func classifyLaneError(lane, sentinel int, err error) orderedRunError { stage := 1 var laneErr *laneRunError @@ -603,7 +434,6 @@ func mergeLaneOutput(dst *RunOutput, src RunOutput) error { dst.NormalizeOutputs = append(dst.NormalizeOutputs, cloneSerializedOutputs(src.NormalizeOutputs)...) dst.Rejected = append(dst.Rejected, cloneRejectedOutputs(src.Rejected)...) appendDiagnosticGroups(dst, src.diagnosticGroups) - dst.CheckpointEvents = append(dst.CheckpointEvents, src.CheckpointEvents...) dst.ValidationSummaries = append(dst.ValidationSummaries, cloneValidationSummaries(src.ValidationSummaries)...) if len(src.normalizeReuseEligibility) > 0 { if dst.normalizeReuseEligibility == nil { diff --git a/internal/framework/pipeline/runner_typed.go b/internal/framework/pipeline/runner_typed.go index 0a13f19c..4e3a35b3 100644 --- a/internal/framework/pipeline/runner_typed.go +++ b/internal/framework/pipeline/runner_typed.go @@ -1,11 +1,7 @@ package pipeline import ( - "bytes" "context" - "crypto/sha256" - "encoding/hex" - "errors" "fmt" "path" "time" @@ -15,74 +11,6 @@ import ( "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" ) -func loadMerge(loader CheckpointLoader, stepID, laneID, moduleKey string, deps []CheckpointFingerprint) (MergeCheckpoint, CheckpointDecision) { - if stepAware, ok := loader.(StepCheckpointLoader); ok { - return stepAware.MergeForStep(stepID, laneID, moduleKey, deps) - } - return loader.Merge(laneID, moduleKey, deps) -} -func loadNormalize(loader CheckpointLoader, stepID, laneID, moduleKey string, deps []CheckpointFingerprint) (NormalizeCheckpoint, CheckpointDecision) { - if stepAware, ok := loader.(StepCheckpointLoader); ok { - return stepAware.NormalizeForStep(stepID, laneID, moduleKey, deps) - } - return loader.Normalize(laneID, moduleKey, deps) -} -func recordMerge(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - return checkpointMergeSucceeded(recorder, stepID, laneID, moduleKey, deps, output) -} -func recordNormalize(recorder CheckpointRecorder, stepID, laneID, moduleKey string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - return checkpointNormalizeSucceeded(recorder, stepID, laneID, moduleKey, deps, output) -} -func cloneCheckpointArtifact(output CheckpointArtifact) CheckpointArtifact { - output.Artifact = contracts.CloneSerializedArtifact(output.Artifact) - output.Diagnostics = cloneCheckpointDiagnostics(output.Diagnostics) - return output -} - -func hydrateCheckpointArtifact(codec artifactCodecEntry, output CheckpointArtifact, value any) (CheckpointArtifact, error) { - output.Artifact.Schema = contracts.CloneArtifactSchema(codec.spec.Schema) - if codec.metadata != nil { - metadata, err := codec.metadata(value) - if err != nil { - return CheckpointArtifact{}, fmt.Errorf("clone artifact metadata: %w", err) - } - output.Artifact.Metadata = metadata - } else { - output.Artifact.Metadata = nil - } - return output, nil -} -func artifactCheckpointDigests(outputs []CheckpointArtifact) []CheckpointFingerprint { - values := make([]CheckpointFingerprint, 0, len(outputs)) - for i, output := range outputs { - sum := sha256.Sum256(output.Artifact.Content) - values = append(values, CheckpointFingerprint{Name: fmt.Sprintf("artifact[%d]", i), Value: "sha256:" + hex.EncodeToString(sum[:])}) - } - return normalizeCheckpointFingerprints(values) -} -func debugCheckpointArtifact(output CheckpointArtifact) map[string]any { - artifact := output.Artifact - schema := contracts.CloneArtifactSchema(artifact.Schema) - digest := output.SchemaDigest - if digest == "" { - digest = contracts.DigestArtifactSchema(schema) - } - schema.JSONSchema = nil - content := debugContentEnvelope(artifact.Content, artifact.MediaType, artifact.Metadata, nil) - content.ContentDigest = debugContentDigest(artifact.Content) - return map[string]any{"lane_id": output.LaneID, "module_key": output.ModuleKey, "source_id": output.SourceID, "chunk_id": output.ChunkID, "chunk_index": output.ChunkIndex, "chunk_ref": output.ChunkRef, "artifact_kind": artifact.Kind, "schema": schema, "schema_digest": digest, "content": content} -} -func debugCheckpointArtifacts(outputs []CheckpointArtifact) []map[string]any { - if len(outputs) == 0 { - return nil - } - out := make([]map[string]any, 0, len(outputs)) - for _, output := range outputs { - out = append(out, debugCheckpointArtifact(output)) - } - return out -} - func serializeArtifact(codec artifactCodecEntry, value any, candidate bool) (contracts.SerializedArtifact, error) { encode := codec.encode if candidate { @@ -103,82 +31,6 @@ func serializeArtifact(codec artifactCodecEntry, value any, candidate bool) (con return contracts.SerializedArtifact{Kind: codec.spec.Kind, Schema: contracts.CloneArtifactSchema(schema), MediaType: codec.spec.MediaType, Content: append([]byte(nil), content...), Metadata: metadata}, nil } -type checkpointArtifactValidationError struct { - code CheckpointReasonCode - err error -} - -func (e *checkpointArtifactValidationError) Error() string { return e.err.Error() } -func (e *checkpointArtifactValidationError) Unwrap() error { return e.err } - -func checkpointArtifactValidationFailure(code CheckpointReasonCode, format string, args ...any) error { - return &checkpointArtifactValidationError{code: code, err: fmt.Errorf(format, args...)} -} - -func checkpointArtifactReasonCode(err error) CheckpointReasonCode { - var validationErr *checkpointArtifactValidationError - if errors.As(err, &validationErr) { - return validationErr.code - } - return CheckpointReasonArtifactPayloadInvalid -} - -func decodeCheckpointArtifact(codec artifactCodecEntry, artifact CheckpointArtifact) (any, error) { - expectedDigest := contracts.DigestArtifactSchema(codec.spec.Schema) - if artifact.Artifact.Kind != codec.spec.Kind { - return nil, checkpointArtifactValidationFailure(CheckpointReasonArtifactCodecIncompatible, "artifact kind %q does not match codec %q", artifact.Artifact.Kind, codec.spec.Kind) - } - if artifact.Artifact.Schema.ID != codec.spec.Schema.ID || artifact.Artifact.Schema.Name != codec.spec.Schema.Name || artifact.Artifact.Schema.Version != codec.spec.Schema.Version { - return nil, checkpointArtifactValidationFailure(CheckpointReasonArtifactCodecIncompatible, "artifact schema %q version %q does not match codec schema %q version %q", artifact.Artifact.Schema.ID, artifact.Artifact.Schema.Version, codec.spec.Schema.ID, codec.spec.Schema.Version) - } - if artifact.SchemaDigest != expectedDigest { - return nil, checkpointArtifactValidationFailure(CheckpointReasonArtifactCodecIncompatible, "artifact schema digest %q does not match codec schema digest %q", artifact.SchemaDigest, expectedDigest) - } - if artifact.Artifact.MediaType != codec.spec.MediaType { - return nil, checkpointArtifactValidationFailure(CheckpointReasonArtifactCodecIncompatible, "artifact media type %q does not match codec media type %q", artifact.Artifact.MediaType, codec.spec.MediaType) - } - value, err := codec.decode(append([]byte(nil), artifact.Artifact.Content...)) - if err != nil { - return nil, checkpointArtifactValidationFailure(CheckpointReasonArtifactPayloadInvalid, "decode artifact payload: %w", err) - } - return value, nil -} - -func decodeCanonicalCheckpointArtifact(codec artifactCodecEntry, artifact CheckpointArtifact) (any, CheckpointArtifact, error) { - value, err := decodeCheckpointArtifact(codec, artifact) - if err != nil { - return nil, CheckpointArtifact{}, err - } - canonical, err := serializeArtifact(codec, value, false) - if err != nil { - return nil, CheckpointArtifact{}, checkpointArtifactValidationFailure(CheckpointReasonArtifactPayloadInvalid, "encode canonical artifact: %w", err) - } - if canonical.Kind != artifact.Artifact.Kind || canonical.Schema.ID != artifact.Artifact.Schema.ID || canonical.Schema.Name != artifact.Artifact.Schema.Name || canonical.Schema.Version != artifact.Artifact.Schema.Version || canonical.MediaType != artifact.Artifact.MediaType || !bytes.Equal(canonical.Content, artifact.Artifact.Content) || checkpointContentDigest(canonical.Content) != checkpointContentDigest(artifact.Artifact.Content) { - return nil, CheckpointArtifact{}, checkpointArtifactValidationFailure(CheckpointReasonArtifactNotCanonical, "stored artifact is not canonical") - } - hydrated, err := hydrateCheckpointArtifact(codec, cloneCheckpointArtifact(artifact), value) - if err != nil { - return nil, CheckpointArtifact{}, checkpointArtifactValidationFailure(CheckpointReasonArtifactPayloadInvalid, "hydrate checkpoint artifact: %w", err) - } - return value, hydrated, nil -} - -func checkpointArtifact(codec artifactCodecEntry, laneID, moduleKey, sourceID string, value any) (CheckpointArtifact, error) { - serialized, err := serializeArtifact(codec, value, false) - if err != nil { - return CheckpointArtifact{}, err - } - return CheckpointArtifact{LaneID: laneID, ModuleKey: moduleKey, SourceID: sourceID, Artifact: serialized, SchemaDigest: contracts.DigestArtifactSchema(serialized.Schema)}, nil -} - -func serializeCandidateArtifact(codec artifactCodecEntry, laneID, moduleKey, sourceID string, value any) (CheckpointArtifact, error) { - serialized, err := serializeArtifact(codec, value, true) - if err != nil { - return CheckpointArtifact{}, err - } - return CheckpointArtifact{LaneID: laneID, ModuleKey: moduleKey, SourceID: sourceID, Artifact: serialized, SchemaDigest: contracts.DigestArtifactSchema(serialized.Schema)}, nil -} - type laneRunError struct { stage ModuleStage err error @@ -189,17 +41,17 @@ func (e *laneRunError) Unwrap() error { return e.err } type mergeStageResult struct { artifact erasedMergeArtifact - serialized CheckpointArtifact + serialized contracts.SerializedArtifact reuseEligible bool } type normalizeStageResult struct { - serialized CheckpointArtifact + serialized contracts.SerializedArtifact accepted bool reuseEligible bool } -func (r *Runner) continueTypedLane(ctx context.Context, input RunInput, checkpoints CheckpointRecorder, loader CheckpointLoader, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, prepared preparedLaneExecutor, extracts finalizedExtractResults, output *RunOutput) error { +func (r *Runner) continueTypedLane(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, prepared preparedLaneExecutor, extracts finalizedExtractResults, output *RunOutput) error { lane := prepared.resolved if prepared.typed == nil { return fmt.Errorf("typed lane %q executor is not prepared", lane.ID) @@ -207,16 +59,16 @@ func (r *Runner) continueTypedLane(ctx context.Context, input RunInput, checkpoi if err := setTypedLaneManifestMetadata(output, lane.ID, prepared.typed.extractor, prepared.typed.merger, prepared.typed.normalizer); err != nil { return err } - merged, err := r.runMergeStage(ctx, input, checkpoints, loader, doc, sourceInput, sessionID, prepared, extracts, output) + merged, err := r.runMergeStage(ctx, input, doc, sourceInput, sessionID, prepared, extracts, output) if err != nil { return &laneRunError{stage: StageMerge, err: err} } - normalized, err := r.runNormalizeStage(ctx, input, checkpoints, loader, doc, sourceInput, sessionID, prepared, merged.artifact, merged.serialized, merged.reuseEligible, output) + normalized, err := r.runNormalizeStage(ctx, input, doc, sourceInput, sessionID, prepared, merged.artifact, merged.reuseEligible, output) if err != nil { return &laneRunError{stage: StageNormalize, err: err} } if normalized.accepted { - output.NormalizeOutputs = append(output.NormalizeOutputs, contracts.SerializedOutput{StepID: input.stepID, LaneID: lane.ID, NormalizerKey: lane.Normalize.Module, SourceID: doc.ID, Artifact: contracts.CloneSerializedArtifact(normalized.serialized.Artifact)}) + output.NormalizeOutputs = append(output.NormalizeOutputs, contracts.SerializedOutput{StepID: input.stepID, LaneID: lane.ID, NormalizerKey: lane.Normalize.Module, SourceID: doc.ID, Artifact: contracts.CloneSerializedArtifact(normalized.serialized)}) if output.normalizeReuseEligibility == nil { output.normalizeReuseEligibility = make(map[generatedOutputKey]bool) } @@ -225,45 +77,18 @@ func (r *Runner) continueTypedLane(ctx context.Context, input RunInput, checkpoi return nil } -func (r *Runner) runMergeStage(ctx context.Context, input RunInput, checkpoints CheckpointRecorder, loader CheckpointLoader, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, prepared preparedLaneExecutor, extracts finalizedExtractResults, output *RunOutput) (mergeStageResult, error) { +func (r *Runner) runMergeStage(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, prepared preparedLaneExecutor, extracts finalizedExtractResults, output *RunOutput) (mergeStageResult, error) { state := mergeStageResult{} lane, typed := prepared.resolved, prepared.typed references := operationReferenceSet(input, lane.MergeReferences) state.reuseEligible = extracts.reuseEligible && !input.reuseIneligible && referenceTargetReuseEligible(input, lane.MergeReferences) - deps := normalizeCheckpointFingerprints(append(artifactCheckpointDigests(extracts.serialized), generatedReferenceDependencies(references)...)) - var checkpoint MergeCheckpoint - decision := checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonValidationIncompleteLineage) - if state.reuseEligible { - checkpoint, decision = loadMerge(loader, input.stepID, lane.ID, lane.Merge.Module, deps) - } - resolution, err := resolveCheckpointDecision(output, loader, input.CheckpointPolicy, StageMerge, input.stepID, lane.ID, lane.Merge.Module, decision, typed.codec, []CheckpointArtifact{checkpoint.Output}) - if err != nil { - return state, err - } - if resolution.decision.Reused { - state.serialized = resolution.artifacts[0] - state.artifact = erasedMergeArtifact{LaneID: lane.ID, MergerKey: lane.Merge.Module, SourceID: doc.ID, Value: resolution.values[0]} - diagnostics, err := promoteCheckpointDiagnostics(state.serialized.Diagnostics, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageMerge, StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Merge.Module}, nil) - if err != nil { - return state, err - } - appendDiagnosticGroups(output, diagnostics) - return state, nil - } - if err := ctx.Err(); err != nil { - return state, err - } - if state.reuseEligible { - if err := checkpointMergeRunning(checkpoints, input.stepID, lane.ID, lane.Merge.Module, deps); err != nil { - return state, err - } - } - inputs := make([]contracts.ExtractArtifact[any], len(extracts.accepted)) for i, value := range extracts.accepted { inputs[i] = contracts.ExtractArtifact[any]{LaneID: value.LaneID, ExtractorKey: value.ExtractorKey, SourceID: value.SourceID, ChunkID: value.ChunkID, ChunkIndex: value.ChunkIndex, ChunkRef: value.ChunkRef, Value: value.Value} } - + if err := ctx.Err(); err != nil { + return state, err + } metadata, err := cloneMetadata(input.Metadata) if err != nil { return state, err @@ -282,16 +107,13 @@ func (r *Runner) runMergeStage(ctx context.Context, input RunInput, checkpoints operation.Cache = artifactProducerCache(input, typed, lane.MergeExecutionClass, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageMerge, StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Merge.Module}, doc, nil, &cacheDiagnostics) produced, err := typed.merge(ctx, typed.merger, contracts.TypedMergeRequest[any]{Operation: operation, Source: doc, LaneID: lane.ID, ExtractOutputs: inputs, SourceInput: sourceInput.Clone(), SessionID: sessionID, References: CloneReferenceSet(references), LLMProfile: lane.Merge.LLMProfile, Metadata: metadata}) if err != nil { - if state.reuseEligible { - _ = checkpointMergeFailed(checkpoints, input.stepID, lane.ID, lane.Merge.Module, deps, err) - } return state, fmt.Errorf("merge lane %q: %w", lane.ID, err) } value, outcome, err := completeProducerOperation(ctx, lane.MergeExecutionClass, operation, produced.Value, produced.Outcome, produced.Fallback) if err != nil { return state, fmt.Errorf("accept merge lane %q: %w", lane.ID, err) } - state.serialized, err = checkpointArtifact(typed.codec, lane.ID, lane.Merge.Module, doc.ID, value) + state.serialized, err = serializeArtifact(typed.codec, value, false) if err != nil { return state, fmt.Errorf("encode merge lane %q: %w", lane.ID, err) } @@ -305,51 +127,20 @@ func (r *Runner) runMergeStage(ctx context.Context, input RunInput, checkpoints } state.reuseEligible = outcome.ReuseEligible state.artifact = erasedMergeArtifact{LaneID: lane.ID, MergerKey: lane.Merge.Module, SourceID: doc.ID, Value: value} - if state.reuseEligible { - if err := recordMerge(checkpoints, input.stepID, lane.ID, lane.Merge.Module, deps, state.serialized); err != nil { - return state, err - } - } - if err := writeDebugTimed(input.Debug, path.Join("merge", fileio.EncodePathComponent(lane.ID), "output.json"), debugTimedEnvelope{Stage: string(StageMerge), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Merge.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"outcome": outcome, "output": debugCheckpointArtifact(state.serialized)}}); err != nil { + if err := writeDebugTimed(input.Debug, path.Join("merge", fileio.EncodePathComponent(lane.ID), "output.json"), debugTimedEnvelope{Stage: string(StageMerge), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Merge.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"outcome": outcome, "output": debugSerializedOutputEnvelope(contracts.SerializedOutput{StepID: input.stepID, LaneID: lane.ID, SourceID: doc.ID, Artifact: state.serialized})}}); err != nil { return state, err } return state, nil } -func (r *Runner) runNormalizeStage(ctx context.Context, input RunInput, checkpoints CheckpointRecorder, loader CheckpointLoader, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, prepared preparedLaneExecutor, merged erasedMergeArtifact, serializedMerge CheckpointArtifact, upstreamReuseEligible bool, output *RunOutput) (normalizeStageResult, error) { +func (r *Runner) runNormalizeStage(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string, prepared preparedLaneExecutor, merged erasedMergeArtifact, upstreamReuseEligible bool, output *RunOutput) (normalizeStageResult, error) { state := normalizeStageResult{} lane, typed := prepared.resolved, prepared.typed references := operationReferenceSet(input, lane.NormalizeReferences) state.reuseEligible = upstreamReuseEligible && !input.reuseIneligible && referenceTargetReuseEligible(input, lane.NormalizeReferences) - deps := normalizeCheckpointFingerprints(append(artifactCheckpointDigests([]CheckpointArtifact{serializedMerge}), generatedReferenceDependencies(references)...)) - var checkpoint NormalizeCheckpoint - decision := checkpointDecision(CheckpointDecisionExecuted, CheckpointReasonValidationIncompleteLineage) - if state.reuseEligible { - checkpoint, decision = loadNormalize(loader, input.stepID, lane.ID, lane.Normalize.Module, deps) - } - resolution, err := resolveCheckpointDecision(output, loader, input.CheckpointPolicy, StageNormalize, input.stepID, lane.ID, lane.Normalize.Module, decision, typed.codec, []CheckpointArtifact{checkpoint.Output}) - if err != nil { - return state, err - } - if resolution.decision.Reused { - state.serialized = resolution.artifacts[0] - state.accepted = true - diagnostics, err := promoteCheckpointDiagnostics(state.serialized.Diagnostics, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageNormalize, StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Normalize.Module}, nil) - if err != nil { - return state, err - } - appendDiagnosticGroups(output, diagnostics) - return state, nil - } if err := ctx.Err(); err != nil { return state, err } - if state.reuseEligible { - if err := checkpointNormalizeRunning(checkpoints, input.stepID, lane.ID, lane.Normalize.Module, deps); err != nil { - return state, err - } - } - metadata, err := cloneMetadata(input.Metadata) if err != nil { return state, err @@ -368,16 +159,13 @@ func (r *Runner) runNormalizeStage(ctx context.Context, input RunInput, checkpoi operation.Cache = artifactProducerCache(input, typed, lane.NormalizeExecutionClass, contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageNormalize, StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Normalize.Module}, doc, nil, &cacheDiagnostics) produced, err := typed.normalize(ctx, typed.normalizer, contracts.TypedNormalizeRequest[any]{Operation: operation, Source: doc, LaneID: lane.ID, MergeOutput: contracts.MergeArtifact[any]{LaneID: merged.LaneID, MergerKey: merged.MergerKey, SourceID: merged.SourceID, Value: merged.Value}, SourceInput: sourceInput.Clone(), SessionID: sessionID, References: CloneReferenceSet(references), LLMProfile: lane.Normalize.LLMProfile, Metadata: metadata}) if err != nil { - if state.reuseEligible { - _ = checkpointNormalizeFailed(checkpoints, input.stepID, lane.ID, lane.Normalize.Module, deps, err) - } return state, fmt.Errorf("normalize lane %q: %w", lane.ID, err) } value, outcome, err := completeProducerOperation(ctx, lane.NormalizeExecutionClass, operation, produced.Value, produced.Outcome, produced.Fallback) if err != nil { return state, fmt.Errorf("accept normalize lane %q: %w", lane.ID, err) } - state.serialized, err = checkpointArtifact(typed.codec, lane.ID, lane.Normalize.Module, doc.ID, value) + state.serialized, err = serializeArtifact(typed.codec, value, false) if err != nil { return state, fmt.Errorf("encode normalize lane %q: %w", lane.ID, err) } @@ -391,12 +179,7 @@ func (r *Runner) runNormalizeStage(ctx context.Context, input RunInput, checkpoi } state.reuseEligible = outcome.ReuseEligible state.accepted = true - if state.reuseEligible { - if err := recordNormalize(checkpoints, input.stepID, lane.ID, lane.Normalize.Module, deps, state.serialized); err != nil { - return state, err - } - } - if err := writeDebugTimed(input.Debug, path.Join("normalize", fileio.EncodePathComponent(lane.ID), "output.json"), debugTimedEnvelope{Stage: string(StageNormalize), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Normalize.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"outcome": outcome, "output": debugCheckpointArtifact(state.serialized)}}); err != nil { + if err := writeDebugTimed(input.Debug, path.Join("normalize", fileio.EncodePathComponent(lane.ID), "output.json"), debugTimedEnvelope{Stage: string(StageNormalize), StepID: input.stepID, LaneID: lane.ID, ModuleKey: lane.Normalize.Module, StartedAt: time.Now().UTC(), Payload: map[string]any{"outcome": outcome, "output": debugSerializedOutputEnvelope(contracts.SerializedOutput{StepID: input.stepID, LaneID: lane.ID, SourceID: doc.ID, Artifact: state.serialized})}}); err != nil { return state, err } return state, nil diff --git a/internal/framework/pipeline/runner_typed_checkpoint_test.go b/internal/framework/pipeline/runner_typed_checkpoint_test.go deleted file mode 100644 index 23e0bd5f..00000000 --- a/internal/framework/pipeline/runner_typed_checkpoint_test.go +++ /dev/null @@ -1,165 +0,0 @@ -package pipeline - -import ( - "context" - "encoding/json" - "strings" - "testing" - - "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" -) - -type requiredCheckpointLoader struct { - CheckpointLoader - checkpoint ExtractCheckpoint - decision CheckpointDecision -} - -func (l requiredCheckpointLoader) Enabled() bool { return true } -func (l requiredCheckpointLoader) Extract(string, string, []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) { - return l.checkpoint, l.decision -} -func (l requiredCheckpointLoader) AcceptedNormalize(string, string, string) (NormalizeCheckpoint, CheckpointDecision) { - output := CheckpointArtifact{} - if len(l.checkpoint.Outputs) > 0 { - output = l.checkpoint.Outputs[0] - } - return NormalizeCheckpoint{Output: output}, l.decision -} - -func TestRequiredCheckpointFailureRetainsDecision(t *testing.T) { - tests := []struct { - name string - decision CheckpointDecision - corrupt bool - wantCode CheckpointReasonCode - wantAction CheckpointDecisionCategory - }{ - {"missing", NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonMissing), false, CheckpointReasonMissing, CheckpointDecisionExecuted}, - {"corrupt", NewCheckpointDecision(CheckpointDecisionReused, CheckpointReasonReused), true, CheckpointReasonArtifactNotCanonical, CheckpointDecisionExecuted}, - {"incompatible", NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonArtifactCodecIncompatible), false, CheckpointReasonArtifactCodecIncompatible, CheckpointDecisionExecuted}, - {"dependency invalidated", NewCheckpointDecision(CheckpointDecisionDependencyInvalidated, CheckpointReasonDependencyMismatch), false, CheckpointReasonDependencyMismatch, CheckpointDecisionDependencyInvalidated}, - } - for _, test := range tests { - t.Run(test.name, func(t *testing.T) { - prepared := preparedConcurrentPipeline(t, 1) - step := prepared.Steps[0] - lane := step.lanes[0] - doc := prepared.input.(*typedTestInput).doc - checkpoint := ExtractCheckpoint{} - if test.corrupt { - stored, err := checkpointArtifact(lane.typed.codec, lane.resolved.ID, lane.resolved.Normalize.Module, doc.ID, codecNotes{Items: []string{"stored"}}) - if err != nil { - t.Fatal(err) - } - stored.Artifact.Content = []byte(`{"items": ["stored"]}`) - checkpoint.Outputs = []CheckpointArtifact{stored} - } - loader := requiredCheckpointLoader{CheckpointLoader: NoopCheckpointLoader(), checkpoint: checkpoint, decision: test.decision} - policy := CheckpointExecutionPolicy{RequireReusableLanes: map[string]struct{}{CheckpointLaneKey(step.ID, lane.resolved.ID): {}}} - output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), Checkpoint: loader, CheckpointPolicy: policy}) - if err == nil || !strings.Contains(err.Error(), step.ID) || !strings.Contains(err.Error(), lane.resolved.ID) || !strings.Contains(err.Error(), string(test.wantCode)) { - t.Fatalf("Run() error = %v, want step, lane, and reason code %q", err, test.wantCode) - } - var found bool - for _, event := range output.CheckpointEvents { - if event.Stage == string(StageNormalize) && event.StepID == step.ID && event.LaneID == lane.resolved.ID { - found = true - if event.Action != test.wantAction || event.ReasonCode != test.wantCode { - t.Fatalf("checkpoint event = %#v, want action %q and reason %q", event, test.wantAction, test.wantCode) - } - if event.Detail == "" || event.Detail != event.Reason { - t.Fatalf("checkpoint event detail is not code-owned compatibility text: %#v", event) - } - } - } - if !found { - t.Fatalf("required checkpoint decision missing from %#v", output.CheckpointEvents) - } - var manifestFound bool - for _, decision := range output.Manifest.CheckpointDecisions { - if decision.Stage == string(StageNormalize) && decision.StepID == step.ID && decision.LaneID == lane.resolved.ID { - manifestFound = decision.Category == string(test.wantAction) && decision.ReasonCode == string(test.wantCode) - } - } - if !manifestFound { - t.Fatalf("manifest checkpoint decision missing category %q and code %q: %#v", test.wantAction, test.wantCode, output.Manifest.CheckpointDecisions) - } - encoded, marshalErr := json.Marshal(output.CheckpointEvents) - if marshalErr != nil || !strings.Contains(string(encoded), `"category":"`+string(test.wantAction)+`"`) || !strings.Contains(string(encoded), `"reason_code":"`+string(test.wantCode)+`"`) { - t.Fatalf("checkpoint event JSON = %s, error = %v", encoded, marshalErr) - } - }) - } -} - -func TestCheckpointDecisionDetailDoesNotCopyUnknownReasonCode(t *testing.T) { - const sentinel = "opaque-sensitive-value-78421" - decision := NewCheckpointDecision(CheckpointDecisionExecuted, CheckpointReasonCode(sentinel)) - if decision.Detail == "" || decision.Detail != decision.Reason { - t.Fatalf("decision detail is not bounded compatibility text: %#v", decision) - } - if strings.Contains(decision.Detail, sentinel) || strings.Contains(decision.Reason, sentinel) { - t.Fatalf("decision detail copied caller-controlled reason code: %#v", decision) - } -} - -func TestDecodeCheckpointArtifactRejectsIncompatibleCodecIdentityAndBytes(t *testing.T) { - registry := NewArtifactCodecRegistry() - if err := RegisterArtifactCodec(registry, notesCodec()); err != nil { - t.Fatalf("RegisterArtifactCodec: %v", err) - } - codec, _, err := registry.entry("test/notes") - if err != nil { - t.Fatalf("entry: %v", err) - } - artifact, err := serializeArtifact(codec, codecNotes{Items: []string{"one"}}, false) - if err != nil { - t.Fatalf("serializeArtifact: %v", err) - } - base := CheckpointArtifact{Artifact: artifact, SchemaDigest: contracts.DigestArtifactSchema(artifact.Schema)} - - tests := []struct { - name string - mutate func(*CheckpointArtifact) - want string - }{ - {name: "missing kind", mutate: func(v *CheckpointArtifact) { v.Artifact.Kind = "" }, want: "artifact kind"}, - {name: "schema version", mutate: func(v *CheckpointArtifact) { v.Artifact.Schema.Version = "v999" }, want: "does not match codec schema"}, - {name: "schema digest", mutate: func(v *CheckpointArtifact) { v.SchemaDigest = "sha256:different" }, want: "schema digest"}, - {name: "media type", mutate: func(v *CheckpointArtifact) { v.Artifact.MediaType = "text/plain" }, want: "media type"}, - {name: "decode failure", mutate: func(v *CheckpointArtifact) { v.Artifact.Content = []byte(`{"items":[`) }, want: "unexpected EOF"}, - } - for _, test := range tests { - t.Run(test.name, func(t *testing.T) { - stored := cloneCheckpointArtifact(base) - test.mutate(&stored) - if _, err := decodeCheckpointArtifact(codec, stored); err == nil || !strings.Contains(err.Error(), test.want) { - t.Fatalf("decode error = %v, want %q", err, test.want) - } - }) - } -} - -func TestDecodeCanonicalCheckpointArtifactRejectsNonCanonicalBytes(t *testing.T) { - registry := NewArtifactCodecRegistry() - if err := RegisterArtifactCodec(registry, notesCodec()); err != nil { - t.Fatalf("RegisterArtifactCodec: %v", err) - } - codec, _, err := registry.entry("test/notes") - if err != nil { - t.Fatalf("entry: %v", err) - } - artifact, err := serializeArtifact(codec, codecNotes{Items: []string{"one"}}, false) - if err != nil { - t.Fatalf("serializeArtifact: %v", err) - } - stored := CheckpointArtifact{Artifact: artifact, SchemaDigest: contracts.DigestArtifactSchema(artifact.Schema)} - if _, _, err := decodeCanonicalCheckpointArtifact(codec, stored); err != nil { - t.Fatalf("canonical artifact rejected: %v", err) - } - stored.Artifact.Content = []byte(`{"items": ["one"]}`) - if _, _, err := decodeCanonicalCheckpointArtifact(codec, stored); err == nil { - t.Fatal("non-canonical artifact was accepted") - } -} diff --git a/internal/framework/pipeline/synchronized_collaborators.go b/internal/framework/pipeline/synchronized_collaborators.go index 6b3fc348..db1f0b20 100644 --- a/internal/framework/pipeline/synchronized_collaborators.go +++ b/internal/framework/pipeline/synchronized_collaborators.go @@ -1,11 +1,6 @@ package pipeline -import ( - "sync" - - "gitea.maximumdirect.net/eric/notarius/internal/core/source" - "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" -) +import "sync" type lockedDebugRecorder struct { inner DebugRecorder @@ -39,217 +34,3 @@ func (r *lockedDebugRecorder) WriteBytes(name string, data []byte) error { defer r.mu.Unlock() return r.inner.WriteBytes(name, data) } - -type lockedCheckpointLoader struct { - inner CheckpointLoader - mu sync.Mutex -} - -func synchronizedCheckpointLoader(inner CheckpointLoader) CheckpointLoader { - if _, ok := inner.(*lockedCheckpointLoader); ok { - return inner - } - return &lockedCheckpointLoader{inner: inner} -} -func (l *lockedCheckpointLoader) Enabled() bool { - l.mu.Lock() - defer l.mu.Unlock() - return l.inner.Enabled() -} -func (l *lockedCheckpointLoader) Source(key string) (SourceCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - return l.inner.Source(key) -} -func (l *lockedCheckpointLoader) Extract(lane, key string, deps []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - return l.inner.Extract(lane, key, deps) -} -func (l *lockedCheckpointLoader) Merge(lane, key string, deps []CheckpointFingerprint) (MergeCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - return l.inner.Merge(lane, key, deps) -} -func (l *lockedCheckpointLoader) Normalize(lane, key string, deps []CheckpointFingerprint) (NormalizeCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - return l.inner.Normalize(lane, key, deps) -} -func (l *lockedCheckpointLoader) AcceptedNormalize(step, lane, key string) (NormalizeCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - return l.inner.AcceptedNormalize(step, lane, key) -} -func (l *lockedCheckpointLoader) ExtractForStep(step, lane, key string, deps []CheckpointFingerprint) (ExtractCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - if stepAware, ok := l.inner.(StepCheckpointLoader); ok { - return stepAware.ExtractForStep(step, lane, key, deps) - } - return l.inner.Extract(lane, key, deps) -} -func (l *lockedCheckpointLoader) MergeForStep(step, lane, key string, deps []CheckpointFingerprint) (MergeCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - if stepAware, ok := l.inner.(StepCheckpointLoader); ok { - return stepAware.MergeForStep(step, lane, key, deps) - } - return l.inner.Merge(lane, key, deps) -} -func (l *lockedCheckpointLoader) NormalizeForStep(step, lane, key string, deps []CheckpointFingerprint) (NormalizeCheckpoint, CheckpointDecision) { - l.mu.Lock() - defer l.mu.Unlock() - if stepAware, ok := l.inner.(StepCheckpointLoader); ok { - return stepAware.NormalizeForStep(step, lane, key, deps) - } - return l.inner.Normalize(lane, key, deps) -} - -type lockedCheckpointRecorder struct { - inner CheckpointRecorder - mu sync.Mutex -} - -func synchronizedCheckpointRecorder(inner CheckpointRecorder) CheckpointRecorder { - if _, ok := inner.(*lockedCheckpointRecorder); ok { - return inner - } - return &lockedCheckpointRecorder{inner: inner} -} -func (r *lockedCheckpointRecorder) call(fn func() error) error { - r.mu.Lock() - defer r.mu.Unlock() - return fn() -} -func (r *lockedCheckpointRecorder) SourceRunning(key string) error { - return r.call(func() error { return r.inner.SourceRunning(key) }) -} -func (r *lockedCheckpointRecorder) SourceSucceeded(key string, doc *source.SourceDocument) error { - return r.call(func() error { return r.inner.SourceSucceeded(key, doc) }) -} -func (r *lockedCheckpointRecorder) SourceFailed(key string, err error) error { - return r.call(func() error { return r.inner.SourceFailed(key, err) }) -} -func (r *lockedCheckpointRecorder) ExtractRunning(lane, key string, deps []CheckpointFingerprint) error { - return r.call(func() error { return r.inner.ExtractRunning(lane, key, deps) }) -} -func (r *lockedCheckpointRecorder) ExtractSucceeded(lane, key string, deps []CheckpointFingerprint, outputs []CheckpointArtifact, rejected []contracts.RejectedOutput) error { - return r.call(func() error { return r.inner.ExtractSucceeded(lane, key, deps, outputs, rejected) }) -} -func (r *lockedCheckpointRecorder) ExtractFailed(lane, key string, deps []CheckpointFingerprint, err error) error { - return r.call(func() error { return r.inner.ExtractFailed(lane, key, deps, err) }) -} -func (r *lockedCheckpointRecorder) MergeRunning(lane, key string, deps []CheckpointFingerprint) error { - return r.call(func() error { return r.inner.MergeRunning(lane, key, deps) }) -} -func (r *lockedCheckpointRecorder) MergeSucceeded(lane, key string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - return r.call(func() error { return r.inner.MergeSucceeded(lane, key, deps, output) }) -} -func (r *lockedCheckpointRecorder) MergeRejected(lane, key string, deps []CheckpointFingerprint, rejected contracts.RejectedOutput) error { - return r.call(func() error { return r.inner.MergeRejected(lane, key, deps, rejected) }) -} -func (r *lockedCheckpointRecorder) MergeFailed(lane, key string, deps []CheckpointFingerprint, err error) error { - return r.call(func() error { return r.inner.MergeFailed(lane, key, deps, err) }) -} -func (r *lockedCheckpointRecorder) NormalizeRunning(lane, key string, deps []CheckpointFingerprint) error { - return r.call(func() error { return r.inner.NormalizeRunning(lane, key, deps) }) -} -func (r *lockedCheckpointRecorder) NormalizeSucceeded(lane, key string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - return r.call(func() error { return r.inner.NormalizeSucceeded(lane, key, deps, output) }) -} -func (r *lockedCheckpointRecorder) NormalizeRejected(lane, key string, deps []CheckpointFingerprint, rejected contracts.RejectedOutput) error { - return r.call(func() error { return r.inner.NormalizeRejected(lane, key, deps, rejected) }) -} -func (r *lockedCheckpointRecorder) NormalizeFailed(lane, key string, deps []CheckpointFingerprint, err error) error { - return r.call(func() error { return r.inner.NormalizeFailed(lane, key, deps, err) }) -} - -func (r *lockedCheckpointRecorder) ExtractRunningForStep(step, lane, key string, deps []CheckpointFingerprint) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.ExtractRunningForStep(step, lane, key, deps) - } - return r.inner.ExtractRunning(lane, key, deps) - }) -} -func (r *lockedCheckpointRecorder) ExtractSucceededForStep(step, lane, key string, deps []CheckpointFingerprint, outputs []CheckpointArtifact, rejected []contracts.RejectedOutput) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.ExtractSucceededForStep(step, lane, key, deps, outputs, rejected) - } - return r.inner.ExtractSucceeded(lane, key, deps, outputs, rejected) - }) -} -func (r *lockedCheckpointRecorder) ExtractFailedForStep(step, lane, key string, deps []CheckpointFingerprint, err error) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.ExtractFailedForStep(step, lane, key, deps, err) - } - return r.inner.ExtractFailed(lane, key, deps, err) - }) -} -func (r *lockedCheckpointRecorder) MergeRunningForStep(step, lane, key string, deps []CheckpointFingerprint) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.MergeRunningForStep(step, lane, key, deps) - } - return r.inner.MergeRunning(lane, key, deps) - }) -} -func (r *lockedCheckpointRecorder) MergeSucceededForStep(step, lane, key string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.MergeSucceededForStep(step, lane, key, deps, output) - } - return r.inner.MergeSucceeded(lane, key, deps, output) - }) -} -func (r *lockedCheckpointRecorder) MergeRejectedForStep(step, lane, key string, deps []CheckpointFingerprint, rejected contracts.RejectedOutput) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.MergeRejectedForStep(step, lane, key, deps, rejected) - } - return r.inner.MergeRejected(lane, key, deps, rejected) - }) -} -func (r *lockedCheckpointRecorder) MergeFailedForStep(step, lane, key string, deps []CheckpointFingerprint, err error) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.MergeFailedForStep(step, lane, key, deps, err) - } - return r.inner.MergeFailed(lane, key, deps, err) - }) -} -func (r *lockedCheckpointRecorder) NormalizeRunningForStep(step, lane, key string, deps []CheckpointFingerprint) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.NormalizeRunningForStep(step, lane, key, deps) - } - return r.inner.NormalizeRunning(lane, key, deps) - }) -} -func (r *lockedCheckpointRecorder) NormalizeSucceededForStep(step, lane, key string, deps []CheckpointFingerprint, output CheckpointArtifact) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.NormalizeSucceededForStep(step, lane, key, deps, output) - } - return r.inner.NormalizeSucceeded(lane, key, deps, output) - }) -} -func (r *lockedCheckpointRecorder) NormalizeRejectedForStep(step, lane, key string, deps []CheckpointFingerprint, rejected contracts.RejectedOutput) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.NormalizeRejectedForStep(step, lane, key, deps, rejected) - } - return r.inner.NormalizeRejected(lane, key, deps, rejected) - }) -} -func (r *lockedCheckpointRecorder) NormalizeFailedForStep(step, lane, key string, deps []CheckpointFingerprint, err error) error { - return r.call(func() error { - if v, ok := r.inner.(StepCheckpointRecorder); ok { - return v.NormalizeFailedForStep(step, lane, key, deps, err) - } - return r.inner.NormalizeFailed(lane, key, deps, err) - }) -} diff --git a/internal/framework/pipeline/typed_execution.go b/internal/framework/pipeline/typed_execution.go index 1583b94e..af8b06e6 100644 --- a/internal/framework/pipeline/typed_execution.go +++ b/internal/framework/pipeline/typed_execution.go @@ -14,6 +14,7 @@ type erasedExtractArtifact struct { ChunkIndex int ChunkRef source.SourceRef Value any + artifact contracts.SerializedArtifact } type erasedMergeArtifact struct { diff --git a/internal/framework/pipeline/typed_resolution_test.go b/internal/framework/pipeline/typed_resolution_test.go index ad26500b..81d44eb3 100644 --- a/internal/framework/pipeline/typed_resolution_test.go +++ b/internal/framework/pipeline/typed_resolution_test.go @@ -181,7 +181,7 @@ func TestPrepareConstructsHeterogeneousTypedLanes(t *testing.T) { } } -func TestRunExecutesHeterogeneousTypedLanesWithCheckpointsDisabled(t *testing.T) { +func TestRunExecutesHeterogeneousTypedLanes(t *testing.T) { catalog := typedResolutionCatalog(t, completeTypedCatalogOptions()) resolved, err := ResolvePipeline(typedResolutionProfile(), ResolveOptions{}, catalog) if err != nil { @@ -198,9 +198,6 @@ func TestRunExecutesHeterogeneousTypedLanesWithCheckpointsDisabled(t *testing.T) if len(output.NormalizeOutputs) != 2 { t.Fatalf("normalize outputs = %#v, want two typed lane results", output.NormalizeOutputs) } - if len(output.CheckpointEvents) != 0 { - t.Fatalf("checkpoint events = %#v, want none with checkpoint loading disabled", output.CheckpointEvents) - } } func TestResolveTypedLaneRejectsIncompatibleComposition(t *testing.T) {