The two were only different in CI, where filename was "<sha>:ci.fnl"
for Lua tracebacks and display was "ci.fnl" for miette errors. The
sha prefix adds noise users don't recognize, so using the same name
for both simplifies the API without losing useful information.

Assisted-by: GLM-5.1 via pi

diff --git a/src/ci/lua.rs b/src/ci/lua.rs
index 9081a7f..f96106e 100644
--- a/src/ci/lua.rs
+++ b/src/ci/lua.rs
@@ -24,15 +24,14 @@ use crate::secret::SecretString;
 pub(super) fn parse(
     fennel: &Fennel,
     source: &str,
-    filename: &str,
-    display: &str,
+    name: &str,
     secrets: HashMap<String, SecretString>,
 ) -> Result<Vec<std::result::Result<Job, ValidationError>>> {
     let jobs = Rc::new(RefCell::new(Vec::new()));
     let src = Rc::new(source.to_string());
     let secrets = Rc::new(secrets);
 
-    fennel.eval_raw(source, filename, display, |lua| {
+    fennel.eval_raw(source, name, |lua| {
         let module = CiModule {
             jobs: jobs.clone(),
             source: src.clone(),
@@ -300,8 +299,7 @@ mod tests {
         );
         let source = r#"(local ci (require :quire.ci))
 (ci.job :grab [:quire/push] (fn [_] (ci.secret :github_token)))"#;
-        let pipeline =
-            Pipeline::load(source, "ci.fnl", "ci.fnl", secrets).expect("load should succeed");
+        let pipeline = Pipeline::load(source, "ci.fnl", secrets).expect("load should succeed");
         let token: String = pipeline.jobs()[0]
             .run_fn
             .call(())
@@ -313,8 +311,8 @@ mod tests {
     fn ci_secret_errors_for_unknown_name() {
         let source = r#"(local ci (require :quire.ci))
 (ci.job :grab [:quire/push] (fn [_] (ci.secret :missing)))"#;
-        let pipeline = Pipeline::load(source, "ci.fnl", "ci.fnl", HashMap::new())
-            .expect("load should succeed");
+        let pipeline =
+            Pipeline::load(source, "ci.fnl", HashMap::new()).expect("load should succeed");
         let err = pipeline.jobs()[0]
             .run_fn
             .call::<mlua::Value>(())
@@ -330,8 +328,8 @@ mod tests {
     /// invoke it, and decode the resulting Lua table as ShOutput through
     /// the pipeline's VM via `lua.from_value`.
     fn run_sh_via_job(source: &str) -> ShOutput {
-        let pipeline = Pipeline::load(source, "ci.fnl", "ci.fnl", HashMap::new())
-            .expect("load should succeed");
+        let pipeline =
+            Pipeline::load(source, "ci.fnl", HashMap::new()).expect("load should succeed");
         let value: mlua::Value = pipeline.jobs()[0]
             .run_fn
             .call(())
@@ -410,7 +408,6 @@ mod tests {
         let pipeline = Pipeline::load(
             r#"(local ci (require :quire.ci))
 (ci.job :go [:quire/push] (fn [_] (ci.sh "echo hi" {:cwdir "/tmp"})))"#,
-            "ci.fnl",
             "ci.fnl",
             HashMap::new(),
         )
@@ -431,7 +428,6 @@ mod tests {
         let pipeline = Pipeline::load(
             r#"(local ci (require :quire.ci))
 (ci.job :go [:quire/push] (fn [_] (ci.sh {:env {:FOO "bar"}})))"#,
-            "ci.fnl",
             "ci.fnl",
             HashMap::new(),
         )
@@ -452,7 +448,6 @@ mod tests {
         let pipeline = Pipeline::load(
             r#"(local ci (require :quire.ci))
 (ci.job :go [:quire/push] (fn [_] (ci.sh [])))"#,
-            "ci.fnl",
             "ci.fnl",
             HashMap::new(),
         )
diff --git a/src/ci/mod.rs b/src/ci/mod.rs
index 6c8658b..90391db 100644
--- a/src/ci/mod.rs
+++ b/src/ci/mod.rs
@@ -66,8 +66,7 @@ impl Ci {
             return Ok(None);
         };
         let name = CI_FNL.to_string();
-        let lua_name = format!("{}:{CI_FNL}", commit.sha);
-        let pipeline = Pipeline::load(&source, &lua_name, &name, secrets)?;
+        let pipeline = Pipeline::load(&source, &name, secrets)?;
         Ok(Some(pipeline))
     }
 
@@ -173,9 +172,8 @@ fn trigger_ref(
     run.transition(RunState::Active)?;
 
     let name = CI_FNL.to_string();
-    let lua_name = format!("{}:{CI_FNL}", push_ref.new_sha);
 
-    match Pipeline::load(&source, &lua_name, &name, secrets) {
+    match Pipeline::load(&source, &name, secrets) {
         Ok(_pipeline) => run.transition(RunState::Complete)?,
         Err(e) => {
             run.transition(RunState::Failed)?;
diff --git a/src/ci/pipeline.rs b/src/ci/pipeline.rs
index aa8ddeb..816c8b9 100644
--- a/src/ci/pipeline.rs
+++ b/src/ci/pipeline.rs
@@ -126,12 +126,11 @@ impl Pipeline {
     /// for miette to render with inline labels.
     pub(crate) fn load(
         source: &str,
-        filename: &str,
-        display: &str,
+        name: &str,
         secrets: HashMap<String, SecretString>,
     ) -> Result<Pipeline> {
         let fennel = Fennel::new()?;
-        let results = lua::parse(&fennel, source, filename, display, secrets)?;
+        let results = lua::parse(&fennel, source, name, secrets)?;
 
         let mut errors = Vec::new();
         let mut jobs = Vec::new();
@@ -157,7 +156,7 @@ impl Pipeline {
             })
         } else {
             Err(LoadError {
-                src: NamedSource::new(display, source.to_string()),
+                src: NamedSource::new(name, source.to_string()),
                 errors,
             }
             .into())
@@ -344,8 +343,8 @@ mod tests {
     fn load_registers_a_job() {
         let source = r#"(local ci (require :quire.ci))
 (ci.job :test [:quire/push] (fn [_] nil))"#;
-        let pipeline = Pipeline::load(source, "ci.fnl", "ci.fnl", HashMap::new())
-            .expect("load should succeed");
+        let pipeline =
+            Pipeline::load(source, "ci.fnl", HashMap::new()).expect("load should succeed");
         let jobs = pipeline.jobs();
         assert_eq!(jobs.len(), 1);
         assert_eq!(jobs[0].id, "test");
@@ -359,8 +358,8 @@ mod tests {
 (ci.job :build [:quire/push] (fn [_] nil))
 (ci.job :test [:build] (fn [_] nil))
 "#;
-        let pipeline = Pipeline::load(source, "ci.fnl", "ci.fnl", HashMap::new())
-            .expect("load should succeed");
+        let pipeline =
+            Pipeline::load(source, "ci.fnl", HashMap::new()).expect("load should succeed");
         let jobs = pipeline.jobs();
         assert_eq!(jobs.len(), 2);
         assert_eq!(jobs[0].id, "build");
@@ -377,8 +376,8 @@ mod tests {
 
 
 (ci.job :sixth [:quire/push] (fn [_] nil))";
-        let pipeline = Pipeline::load(source, "ci.fnl", "ci.fnl", HashMap::new())
-            .expect("load should succeed");
+        let pipeline =
+            Pipeline::load(source, "ci.fnl", HashMap::new()).expect("load should succeed");
         let lines: Vec<usize> = pipeline
             .jobs()
             .iter()
@@ -389,7 +388,7 @@ mod tests {
 
     #[test]
     fn load_errors_on_bad_fennel() {
-        let result = Pipeline::load("{:bad {:}", "ci.fnl", "ci.fnl", HashMap::new());
+        let result = Pipeline::load("{:bad {:}", "ci.fnl", HashMap::new());
         assert!(result.is_err(), "malformed Fennel should fail");
     }
 
@@ -399,7 +398,7 @@ mod tests {
     /// but the returned `Job`s only need their non-VM fields here.
     fn parse_results(source: &str) -> Vec<std::result::Result<Job, ValidationError>> {
         let f = Fennel::new().expect("Fennel::new() should succeed");
-        lua::parse(&f, source, "ci.fnl", "ci.fnl", HashMap::new()).expect("parse should succeed")
+        lua::parse(&f, source, "ci.fnl", HashMap::new()).expect("parse should succeed")
     }
 
     /// Discard parse errors and return only the successfully registered
diff --git a/src/ci/run.rs b/src/ci/run.rs
index ea3840d..ffbb79f 100644
--- a/src/ci/run.rs
+++ b/src/ci/run.rs
@@ -641,13 +641,8 @@ mod tests {
     }
 
     fn load(source: &str) -> Pipeline {
-        super::super::pipeline::Pipeline::load(
-            source,
-            "ci.fnl",
-            "ci.fnl",
-            std::collections::HashMap::new(),
-        )
-        .expect("load should succeed")
+        super::super::pipeline::Pipeline::load(source, "ci.fnl", std::collections::HashMap::new())
+            .expect("load should succeed")
     }
 
     #[test]
diff --git a/src/fennel.rs b/src/fennel.rs
index 04b12dd..1508f35 100644
--- a/src/fennel.rs
+++ b/src/fennel.rs
@@ -85,16 +85,15 @@ impl Fennel {
     /// `setup` is called before evaluation and can inject globals or
     /// modify the VM.
     ///
-    /// `filename` is passed to Lua as the source name (used in tracebacks).
-    /// `display` is used in miette error messages (can be more human-readable).
+    /// `name` is used as the Lua source name (for tracebacks) and in
+    /// miette error messages.
     pub fn eval_raw(
         &self,
         source: &str,
-        filename: &str,
-        display: &str,
+        name: &str,
         setup: impl Fn(&Lua) -> mlua::Result<()>,
     ) -> Result<mlua::Value, FennelError> {
-        setup(&self.lua).map_err(|e| FennelError::from_lua(source, display, e))?;
+        setup(&self.lua).map_err(|e| FennelError::from_lua(source, name, e))?;
 
         let fennel: mlua::Table = self.lua.globals().get("fennel")?;
 
@@ -102,14 +101,14 @@ impl Fennel {
 
         let opts = self.lua.create_table()?;
 
-        opts.set("filename", filename)?;
+        opts.set("filename", name)?;
         // Align Lua line numbers with Fennel source lines so debug
         // info points back at the user's `.fnl`.
         opts.set("correlate", true)?;
 
         let result = eval
             .call::<mlua::Value>((source, opts))
-            .map_err(|e| FennelError::from_lua(source, display, e))?;
+            .map_err(|e| FennelError::from_lua(source, name, e))?;
 
         Ok(result)
     }
@@ -129,7 +128,7 @@ impl Fennel {
             });
         }
 
-        let result = self.eval_raw(source, name, name, |_| Ok(()))?;
+        let result = self.eval_raw(source, name, |_| Ok(()))?;
 
         // Reject nil results — a config file that evaluates to nothing is
         // almost always a mistake.