feat(cargo-mono): always forward --no-verify on publish (#348)

## Summary
- always pass `--no-verify` to delegated `cargo publish` calls,
including dry-run mode
- update publish error context, CLI help text, and cargo-mono docs to
describe the new contract
- extend integration coverage to assert forwarded cargo publish flags in
execute and dry-run flows

## Testing
- cargo test -p cargo-mono
- cargo test

Author: kdy1

crates/AGENTS.md

@@ -35,6 +35,7 @@
 - Keep command identifiers stable and documented in `docs/project-cargo-mono.md` and `docs/crates-cargo-mono-foundation.md`.
 - Preserve `cargo mono` subcommand compatibility (`cargo-mono` binary naming contract).
 - Keep release-tag responsibility split: `bump` must not create tags, and `publish` may create tags only for packages listed in `[workspace.metadata.cargo-mono.publish.tag].packages`.
+- Keep `publish` delegation aligned with the documented contract: `cargo mono publish` must invoke `cargo publish --no-verify` in both execute and dry-run modes.
 - Ensure release automation (`bump`, `publish`) logs include structured operational context.
 - Keep runtime error output on the fixed `Summary/Context/Hint` three-line contract and include only safe debugging context values.
 

crates/cargo-mono/README.md

@@ -11,6 +11,9 @@ cargo mono bump [--all|--changed|--package <name>] --level <major|minor|patch|pr
 cargo mono publish [--all|--changed|--package <name>] [--dry-run]
 ```
 
+`cargo mono publish` always delegates to `cargo publish --no-verify`, including `--dry-run`
+execution.
+
 ## Publish Tag Configuration
 
 `cargo mono publish` can create local Git tags for published crates when opt-in allowlist
@@ -40,7 +43,7 @@ Coverage highlights:
 - `list`: workspace discovery and publishability reporting.
 - `changed`: base override, include/exclude filters, invalid glob rejection, direct-only vs dependent expansion, include-uncommitted behavior, and global-impact file handling.
 - `bump`: clean-tree preflight, non-publishable skip behavior, manifest/version/dependency updates, dependent patch propagation, and release commit creation (no tag creation).
-- `publish`: clean-tree preflight, non-publishable skip behavior, unknown package validation, and allowlist-based publish tag creation.
+- `publish`: clean-tree preflight, fixed `--no-verify` delegation (including dry-run), unknown package validation, and allowlist-based publish tag creation.
 - Cargo external-subcommand mode compatibility (`cargo mono ...`) and top-level help/version behavior outside workspaces.
 
 ## Local Validation

crates/cargo-mono/src/cli.rs

@@ -144,7 +144,8 @@ pub struct PublishArgs {
     pub target: TargetArgs,
     #[command(flatten)]
     pub changed: ChangedArgs,
-    /// Validate publish without uploading artifacts.
+    /// Run the publish flow without uploading artifacts; delegated Cargo
+    /// verification remains disabled.
     #[arg(long)]
     pub dry_run: bool,
     /// Allow execution with a dirty working tree.

crates/cargo-mono/src/commands/publish.rs

@@ -30,6 +30,7 @@ pub(super) const PUBLISH_PREFETCH_CONCURRENCY_ENV: &str = "CARGO_MONO_PUBLISH_PR
 const DEFAULT_PREFETCH_CONCURRENCY: usize = 16;
 const MAX_PREFETCH_CONCURRENCY: usize = 64;
 const PREFETCH_HTTP_TIMEOUT: Duration = Duration::from_secs(15);
+const PUBLISH_NO_VERIFY: bool = true;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum PublishFailureKind {
@@ -264,6 +265,7 @@ pub fn execute(args: &PublishArgs, output: OutputSettings, app: &CargoMonoApp) -
                 outcome = "attempt",
                 retry_attempt = attempts,
                 mode = mode.as_str(),
+                no_verify = PUBLISH_NO_VERIFY,
                 "Publishing package"
             );
 
@@ -956,7 +958,11 @@ fn merge_prefetch_lookup_results(
 
 fn run_publish_command(package: &str, dry_run: bool, registry: Option<&str>) -> Result<Output> {
     let mut command = Command::new("cargo");
-    command.arg("publish").arg("-p").arg(package);
+    command
+        .arg("publish")
+        .arg("-p")
+        .arg(package)
+        .arg("--no-verify");
 
     if dry_run {
         command.arg("--dry-run");
@@ -973,6 +979,7 @@ fn run_publish_command(package: &str, dry_run: bool, registry: Option<&str>) ->
             vec![
                 ("package", package.to_string()),
                 ("dry_run", dry_run.to_string()),
+                ("no_verify", PUBLISH_NO_VERIFY.to_string()),
                 ("registry", registry.unwrap_or("default").to_string()),
                 ("error", error.to_string()),
             ],
@@ -996,6 +1003,7 @@ fn format_publish_failure(
         ("attempt", attempts.to_string()),
         ("status", status.to_string()),
         ("dry_run", dry_run.to_string()),
+        ("no_verify", PUBLISH_NO_VERIFY.to_string()),
         ("registry", registry.unwrap_or("default").to_string()),
     ];
     if !details.is_empty() {
@@ -1034,6 +1042,7 @@ fn format_publish_retry_limit_failure(
             ("attempts", attempts.to_string()),
             ("max_attempts", MAX_PUBLISH_ATTEMPTS.to_string()),
             ("dry_run", dry_run.to_string()),
+            ("no_verify", PUBLISH_NO_VERIFY.to_string()),
             ("registry", registry.unwrap_or("default").to_string()),
         ],
         "Wait for index propagation or rate limits to clear, then rerun publish.",
@@ -1214,6 +1223,7 @@ mod tests {
         assert!(message.contains("package=alpha"));
         assert!(message.contains("attempt=1"));
         assert!(message.contains("status=exit status: 101"));
+        assert!(message.contains("no_verify=true"));
         assert!(message.contains("Hint: "));
     }
 
@@ -1229,6 +1239,7 @@ mod tests {
         );
         assert!(message.contains("details_excerpt=error: network timeout"));
         assert!(message.contains("dry_run=true"));
+        assert!(message.contains("no_verify=true"));
         assert!(message.contains("registry=default"));
         assert!(message.contains("Hint: "));
     }
@@ -1263,6 +1274,7 @@ mod tests {
         );
         assert!(message.contains("attempts=3"));
         assert!(message.contains("max_attempts=3"));
+        assert!(message.contains("no_verify=true"));
         assert!(message.contains("registry=internal"));
         assert!(message.contains("Hint: "));
     }

crates/cargo-mono/tests/cli.rs

@@ -766,6 +766,67 @@ fn publish_dry_run_does_not_create_tags_even_with_allowlist() {
     assert_eq!(result["published"][0]["name"], json!("alpha"));
     assert_eq!(result["tags"], json!([]));
     assert!(git_tags(temp_dir.path()).is_empty());
+    assert_eq!(
+        read_fake_publish_args(temp_dir.path()),
+        vec![
+            "publish".to_string(),
+            "-p".to_string(),
+            "alpha".to_string(),
+            "--no-verify".to_string(),
+            "--dry-run".to_string(),
+        ]
+    );
+}
+
+#[test]
+fn publish_exec_forwards_no_verify_to_cargo_publish() {
+    let temp_dir = init_mixed_publishability_workspace();
+
+    let mut command = cargo_mono_command_with_fake_publish(temp_dir.path());
+    command
+        .current_dir(temp_dir.path())
+        .args(["publish", "--allow-dirty", "--package", "alpha"])
+        .assert()
+        .success();
+
+    assert_eq!(
+        read_fake_publish_args(temp_dir.path()),
+        vec![
+            "publish".to_string(),
+            "-p".to_string(),
+            "alpha".to_string(),
+            "--no-verify".to_string(),
+        ]
+    );
+}
+
+#[test]
+fn publish_dry_run_forwards_no_verify_to_cargo_publish() {
+    let temp_dir = init_mixed_publishability_workspace();
+
+    let mut command = cargo_mono_command_with_fake_publish(temp_dir.path());
+    command
+        .current_dir(temp_dir.path())
+        .args([
+            "publish",
+            "--dry-run",
+            "--allow-dirty",
+            "--package",
+            "alpha",
+        ])
+        .assert()
+        .success();
+
+    assert_eq!(
+        read_fake_publish_args(temp_dir.path()),
+        vec![
+            "publish".to_string(),
+            "-p".to_string(),
+            "alpha".to_string(),
+            "--no-verify".to_string(),
+            "--dry-run".to_string(),
+        ]
+    );
 }
 
 #[test]
@@ -863,6 +924,8 @@ fn cargo_mono_command_with_fake_publish(working_dir: &Path) -> Command {
 set -euo pipefail
 
 if [ "${1-}" = "publish" ]; then
+  : "${FAKE_CARGO_PUBLISH_ARGS_FILE:?}"
+  printf '%s\n' "$@" > "${FAKE_CARGO_PUBLISH_ARGS_FILE}"
   exit 0
 fi
 
@@ -883,10 +946,24 @@ exec "${REAL_CARGO:?}" "$@"
 
     let mut command = cargo_mono_command();
     command.env("REAL_CARGO", env!("CARGO"));
+    command.env(
+        "FAKE_CARGO_PUBLISH_ARGS_FILE",
+        fake_publish_args_path(working_dir),
+    );
     command.env("PATH", path_with_prepend(&fake_bin_directory));
     command
 }
 
+fn fake_publish_args_path(working_dir: &Path) -> PathBuf {
+    working_dir.join(".fake-publish-args")
+}
+
+fn read_fake_publish_args(working_dir: &Path) -> Vec<String> {
+    let raw = fs::read_to_string(fake_publish_args_path(working_dir))
+        .expect("failed to read fake cargo publish args");
+    raw.lines().map(str::to_string).collect()
+}
+
 fn path_with_prepend(prefix: &Path) -> OsString {
     let mut paths = Vec::from([PathBuf::from(prefix)]);
     if let Some(current_path) = std::env::var_os("PATH") {

docs/crates-cargo-mono-foundation.md

@@ -19,6 +19,7 @@
 - Publish and bump workflows must preserve scriptable output contracts for automation.
 - `bump` must not create Git tags.
 - `publish` is the only command allowed to create release tags, and only for packages listed in `[workspace.metadata.cargo-mono.publish.tag].packages`.
+- `publish` must always delegate to `cargo publish --no-verify`, including when `cargo mono publish --dry-run` is used.
 - Publish tag creation is opt-in by default (no config means no tags), must remain local-only (`git tag` without push), and must use `<crate>@v<version>` naming.
 - Remote tag publication is owned by CI automation: `.github/workflows/auto-publish.yml` must run `git push --tags` after a successful `publish` command, with checkout credential persistence disabled and authentication bound to `secrets.GH_TOKEN` (non-`GITHUB_TOKEN`) so downstream tag-triggered workflows run.
 - If `publish` tag configuration references unknown workspace packages, command execution must fail with `invalid-input`.

docs/project-cargo-mono.md

@@ -16,6 +16,7 @@ Provide a Cargo subcommand for Rust monorepo lifecycle management, including ver
 - The binary must remain compatible with `cargo mono` invocation conventions.
 - Release automation integration must keep stable command semantics.
 - Release tagging responsibility is split by command: `bump` must not create Git tags, while `publish` may create local Git tags for configured packages.
+- `publish` must delegate to `cargo publish --no-verify` for all package uploads and dry-run executions.
 - Remote tag publication remains CI-owned: `auto-publish` pushes release tags with `git push --tags` after a successful `publish` run, with checkout credential persistence disabled and authentication bound to `secrets.GH_TOKEN` (non-`GITHUB_TOKEN`) so downstream tag-triggered workflows run.
 - Publish tag configuration must be opt-in through `[workspace.metadata.cargo-mono.publish.tag].packages`, and tag naming must remain `<crate>@v<version>`.
 - Tag release automation must detect `cargo-mono@v*` and produce signed multi-OS prebuilt artifacts without changing CLI command behavior.