Select prompt metadata for inspection

internal/usecase/requirements_inspection_test.go

@@ -24,6 +24,13 @@ type requirementInspectionPromptRepository struct {
 	snapshotVersion string
 }
 
+type requirementPromptMetadataRepository struct {
+	*requirementInspectionPromptRepository
+	inspection    domain.PromptInspection
+	lookupID      string
+	lookupVersion string
+}
+
 type inspectionProfileIdentityRepository struct {
 	*inspectionProfileRepository
 	identity      string
@@ -49,6 +56,18 @@ func (repository *requirementInspectionPromptRepository) GetPromptDefinition(
 	return repository.definition, repository.lookupErr
 }
 
+func (repository *requirementPromptMetadataRepository) GetPromptInspection(
+	_ context.Context,
+	id string,
+	version string,
+) (*domain.PromptInspection, error) {
+	repository.lookupID = id
+	repository.lookupVersion = version
+	inspection := repository.inspection
+	inspection.Inputs = append([]domain.PromptInput(nil), inspection.Inputs...)
+	return &inspection, nil
+}
+
 func (repository *requirementInspectionPromptRepository) GetPromptSnapshot(
 	_ context.Context,
 	id string,
@@ -111,6 +130,50 @@ func TestRunnerInspectRequirementsUsesCapturedSelectionWithoutExecutionWork(t *t
 	}
 }
 
+func TestRunnerInspectRequirementsUsesPromptMetadataAndExactRequirementSnapshot(t *testing.T) {
+	message, err := prompt.CompileTemplate("message", `{{input "message-input"}} {{.caller}}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, err := prompt.CompileTemplate("session", `{{input "session-only"}}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	baseRepository := &requirementInspectionPromptRepository{
+		snapshotFound: true,
+		snapshot: prompt.RequirementSnapshot{Templates: prompt.CompiledTemplates{
+			Messages: []*template.Template{message}, Session: session,
+		}},
+	}
+	promptRepository := &requirementPromptMetadataRepository{
+		requirementInspectionPromptRepository: baseRepository,
+		inspection: domain.PromptInspection{
+			PromptID: "captured-id", PromptVersion: "captured-version", PromptHash: "captured-hash",
+			DefaultProfileID: "default-profile",
+		},
+	}
+	profiles := &inspectionProfileIdentityRepository{
+		inspectionProfileRepository: &inspectionProfileRepository{},
+		identity:                    "default-profile",
+	}
+	inspection, err := (&Runner{promptDefs: promptRepository, profiles: profiles}).InspectRequirements(
+		context.Background(), RequirementInspectionRequest{
+			PromptID: " requested-id ", PromptVersion: " requested-version ",
+			Vars: map[string]string{"caller": "Ada"}, SessionID: " direct-session ",
+		},
+	)
+	if err != nil || promptRepository.lookupID != " requested-id " || promptRepository.lookupVersion != " requested-version " ||
+		baseRepository.snapshotID != "captured-id" || baseRepository.snapshotVersion != "captured-version" ||
+		profiles.identityID != "default-profile" || inspection.PromptID != "captured-id" ||
+		inspection.PromptVersion != "captured-version" || inspection.ProfileID != "default-profile" ||
+		!inspection.Complete || len(inspection.Inputs) != 1 || inspection.Inputs[0].Name != "message-input" ||
+		len(inspection.Variables) != 1 || inspection.Variables[0].Name != "caller" || !inspection.Variables[0].Supplied {
+		t.Fatalf("metadata-based requirement inspection=(%+v, %v), prompt lookup=(%q,%q), snapshot=(%q,%q), profile=%q",
+			inspection, err, promptRepository.lookupID, promptRepository.lookupVersion,
+			baseRepository.snapshotID, baseRepository.snapshotVersion, profiles.identityID)
+	}
+}
+
 func TestRunnerInspectRequirementsUsesProfileIdentityCapabilityOrFallback(t *testing.T) {
 	message, err := prompt.CompileTemplate("message", `{{.name}}`)
 	if err != nil {