@@ -824,6 +824,35 @@ fn display_path(path: &Path) -> String {
     path.display().to_string()
 }
 
+/// C's display name for a scope-selected file: global/system files
+/// print absolute and verbatim (never relativized, even under the
+/// cwd); repo files render relative to the work-tree root
+/// (`.git/config` from anywhere) or the git dir when bare
+/// (`config`), matching C's post-chdir layout.
+fn scope_display_name(
+    repo: Option<&git_core::Repository>,
+    scope: ConfigScope,
+    path: &std::path::Path,
+) -> String {
+    if matches!(scope, ConfigScope::Global | ConfigScope::System) {
+        return path.display().to_string();
+    }
+    if let Some(r) = repo {
+        if let Some(wt) = &r.work_tree {
+            if let Ok(rel) = path.strip_prefix(wt) {
+                if !rel.as_os_str().is_empty() {
+                    return rel.display().to_string();
+                }
+            }
+        } else if let Ok(rel) = path.strip_prefix(&r.git_dir) {
+            if !rel.as_os_str().is_empty() {
+                return rel.display().to_string();
+            }
+        }
+    }
+    display_path(path)
+}
+
 /// C `die_errno` reason for config-file reads: the bare `strerror` text.
 fn io_reason(e: &std::io::Error) -> String {
     match e.kind() {
@@ -1008,7 +1037,7 @@ fn load_read_source(
             let repo = repo.ok_or_else(|| CommandError::fatal("fatal: not in a git directory"))?;
             scope_file(repo, loc)?
         };
-        let display = display_path(&path);
+        let display = scope_display_name(repo, scope, &path);
         // Existence check first: missing reads as empty (list dies on the
         // marker below), unreadable dies — like C.
         let data = match std::fs::read(&path) {
@@ -1066,7 +1095,9 @@ fn load_read_source(
             worktree: repo.work_tree.clone(),
             git_dir_verbatim: repo.git_dir_specified.clone(),
         };
-        let scoped = ConfigSet::load_repo_scoped(&scopes).map_err(|e| match e {
+        // C skips include-following on the layered read under
+        // `--no-includes` (the flag defaults on only with no selector).
+        let scoped = ConfigSet::load_repo_scoped(&scopes, respect).map_err(|e| match e {
             ConfigError::BadLine { line, file } => {
                 let name = file
                     .map(|p| display_path(&p))
@@ -1080,7 +1111,7 @@ fn load_read_source(
                 .entry
                 .origin
                 .as_ref()
-                .map(|p| display_path(p))
+                .map(|p| scope_display_name(Some(repo), s.scope, p))
                 .unwrap_or_default();
             entries.push(LoadedEntry { scope: s.scope, origin: OriginType::File, filename, entry: s.entry });
         }
@@ -1095,7 +1126,7 @@ fn load_read_source(
             roots.push((ConfigScope::Global, g));
         }
         for (scope, path) in roots {
-            let display = display_path(&path);
+            let display = scope_display_name(repo, scope, &path);
             if !path.exists() {
                 continue;
             }
@@ -2567,8 +2598,15 @@ fn write_display_name(ctx: &RepoContext, repo: Option<&git_core::Repository>, lo
     if let Some(file) = &loc.file {
         return file.clone();
     }
+    let scope = if loc.global {
+        ConfigScope::Global
+    } else if loc.system {
+        ConfigScope::System
+    } else {
+        ConfigScope::Local
+    };
     match write_target_file(ctx, repo, loc) {
-        Ok(p) => display_path(&p),
+        Ok(p) => scope_display_name(repo, scope, &p),
         Err(_) => ".git/config".to_string(),
     }
 }
 
@@ -294,6 +294,18 @@ fn log_single_update(
 ) {
     let target = store.deref_name_opt(name, deref);
     let new_now = store.resolve(&target).unwrap_or(*new);
+    // C logs (and writes) nothing for a no-op oid update: old ==
+    // new on a non-symref target, even with --create-reflog — except
+    // that a no-op on the current branch still appends the HEAD
+    // log-only entry (C `split_head_update`).
+    if old == &new_now && read_symref_target(repo, &target).is_none() {
+        if store.head_symbolic_target().as_deref() == Some(target.as_str()) && target != "HEAD" {
+            if let Ok(ident) = crate::checkout_core::committer_ident(repo) {
+                git_refs::reflog::log_update(repo, "HEAD", old, &new_now, &ident, msg);
+            }
+        }
+        return;
+    }
     let Ok(ident) = crate::checkout_core::committer_ident(repo) else { return };
     // C forces the log with `--create-reflog`; otherwise the standard
     // gating applies (`--no-create-reflog` is an accepted no-op).
@@ -796,6 +808,18 @@ impl<'x> BatchRunner<'x> {
                 }
                 None => continue,
             };
+            // C logs (and writes) nothing for a no-op oid update —
+            // except the HEAD log-only entry when the current branch
+            // is the target (C `split_head_update`).
+            if !plog.is_symref_write
+                && new == plog.old
+                && read_symref_target(&self.repo, &plog.target).is_none()
+            {
+                if head_target.as_deref() == Some(plog.target.as_str()) && plog.target != "HEAD" {
+                    self.append_log("HEAD", &plog.old, &new, &ident);
+                }
+                continue;
+            }
             self.append_log(&plog.target, &plog.old, &new, &ident);
             if plog.target != plog.name {
                 self.append_log(&plog.name, &plog.old, &new, &ident);