✅ Add regression guard tests for bsdtar update @ and create -C-only

- archive_inclusion: verify update mode treats @-prefixed operands as
  filesystem paths (not archive inclusion)
- missing_file: verify create mode rejects -C without real input files

Both tests pass on main, proving these are pre-existing correct behaviors.
They guard against regressions when the -C pipeline is changed.

Author: ChanTsune

cli/tests/cli/stdio/archive_inclusion.rs

@@ -718,3 +718,62 @@ fn stdio_archive_inclusion_solid_with_filter() {
         "exclude.log should not be extracted"
     );
 }
+
+/// Precondition: An archive exists and a file whose name starts with @ exists on disk.
+/// Action: Run bsdtar update mode with `@file` as an operand — note the leading `@`.
+/// Expectation: The `@` is NOT interpreted as archive inclusion. The file is added to
+///   the archive as a regular filesystem entry named `@file`.
+#[test]
+fn stdio_update_treats_at_prefix_as_filesystem_path() {
+    setup();
+
+    let base = PathBuf::from("stdio_update_at_prefix_as_path");
+    if base.exists() {
+        fs::remove_dir_all(&base).unwrap();
+    }
+    fs::create_dir_all(&base).unwrap();
+
+    let archive_path = base.join("archive.pna");
+    create_test_archive(&archive_path, &[("original.txt", "original")]);
+
+    // Create a file whose name literally starts with @
+    fs::write(base.join("@data.txt"), "at-content").unwrap();
+
+    // Decoy: if @data.txt were misinterpreted as archive inclusion of "data.txt",
+    // this archive's entries would leak into the result.
+    create_test_archive(&base.join("data.txt"), &[("canary.txt", "canary")]);
+
+    // Pass "@data.txt" — a positional arg starting with @.
+    // -C is infrastructure to make the relative path resolvable.
+    // The actual thing under test is that "@data.txt" is treated as a literal
+    // filesystem path, not parsed as an @archive inclusion reference.
+    cargo_bin_cmd!("pna")
+        .args([
+            "--quiet",
+            "compat",
+            "bsdtar",
+            "--unstable",
+            "-uf",
+            archive_path.to_str().unwrap(),
+            "-C",
+            base.to_str().unwrap(),
+            "@data.txt",
+        ])
+        .assert()
+        .success();
+
+    let entry_names: HashSet<String> = get_archive_entry_names(&archive_path).into_iter().collect();
+    assert!(
+        entry_names.contains("original.txt"),
+        "original entry should be preserved"
+    );
+    assert!(
+        entry_names.contains("@data.txt"),
+        "@ prefix should be part of the entry name, not stripped as archive inclusion"
+    );
+    assert!(
+        !entry_names.contains("canary.txt"),
+        "@data.txt must not be interpreted as archive inclusion of data.txt"
+    );
+    assert_eq!(entry_names.len(), 2, "exactly 2 entries expected");
+}

cli/tests/cli/stdio/missing_file.rs

@@ -1,5 +1,7 @@
 use crate::utils::setup;
 use assert_cmd::cargo::cargo_bin_cmd;
+use std::fs;
+use std::path::PathBuf;
 
 /// Precondition: No input paths are provided.
 /// Action: Run `pna experimental stdio -c -f ...` without positional paths.
@@ -20,3 +22,32 @@ fn stdio_create_without_inputs_fails() {
     ]);
     cmd.assert().failure();
 }
+
+/// Precondition: A directory exists but no real input files are specified.
+/// Action: Run bsdtar create mode with only -C directory-change options
+///   and zero file operands.
+/// Expectation: Command fails — directory changes alone do not constitute input.
+#[test]
+fn stdio_create_with_only_directory_changes_fails() {
+    setup();
+
+    let base = PathBuf::from("stdio_create_only_dir_changes");
+    if base.exists() {
+        fs::remove_dir_all(&base).unwrap();
+    }
+    fs::create_dir_all(&base).unwrap();
+
+    cargo_bin_cmd!("pna")
+        .args([
+            "--quiet",
+            "compat",
+            "bsdtar",
+            "--unstable",
+            "-cf",
+            base.join("out.pna").to_str().unwrap(),
+            "-C",
+            base.to_str().unwrap(),
+        ])
+        .assert()
+        .failure();
+}