bisync: a one-sided delete is reverted when the paths share no hash type and `--ignore-checksum` is set

### Before you start

- [x] I have searched the forum and the existing issues for this problem. The closest match is [forum thread 46636](https://forum.rclone.org/t/46636), which diagnosed the underlying retry cycle but not the consequence reported here (see below).
- [x] I have tested with the latest beta or stable release and can still reproduce the problem (v1.75.1 and v1.76.0-beta.10366.c8d60a67f).
- [x] This is a reproducible bug, not a usage question.

### Associated forum post URL

https://forum.rclone.org/t/46636 (related, not the same report)

### What is the problem you are having with rclone?

When Path1 and Path2 have no hash type in common and `--ignore-checksum` is set, a file that is present and identical on both sides, but absent from the prior listings, is never added to the listings. It is re-examined on every run and rolled back each time. If that file is later deleted on one side, bisync sees it as a new file on the other side and copies it back, so the delete is silently reverted.

**Expected:** once bisync has confirmed the file is identical on both paths, it is recorded in the listings, and a later delete on one side is propagated to the other.

**Actual:** the file is logged as `Files are equal! Skipping`, then `failed to check as hash is missing` and `files not equal on recheck`, and is left out of the listings on every run. After a delete on Path1, the next run logs `Path2 File is new` and `Queue copy to Path1`, and the deleted file is restored.

The reproduction below uses a local directory and a crypt remote, so it needs no cloud account. We first hit this between Dropbox and OneDrive, which also share no hash type. There, files in this state built up over time, and deletes of them made by users on one side were reverted.

#### How a file gets into this state

Any file that is on both sides but missing from the listings, for example:

- a run copied the file but was interrupted or aborted before the listings were saved;
- the file was new on both sides with different content and a sync conflict resolution picked a winner (with `--conflict-resolve newer`, the resolved file is also left out of the listings);
- the same file was placed on both sides independently.

Once in this state, the file never leaves it.

#### Cause

References are to `c8d60a67f`.

1. The file is new on both paths, so `checkconflicts` runs `operations.CheckFn` with bisync's `CheckFn` ([checkfn.go](https://github.com/rclone/rclone/blob/c8d60a67fc5326d5b2fb811cc9036d0103fd5e37/cmd/bisync/checkfn.go#L156)). With no common hash, `CheckFn` returns `noHash`, and `fs/operations` counts a size-equal, `noHash` pair as a match ([check.go](https://github.com/rclone/rclone/blob/c8d60a67fc5326d5b2fb811cc9036d0103fd5e37/fs/operations/check.go#L172)). `deltas.go` then logs `Files are equal! Skipping` and adds the file to `renameSkipped` ([deltas.go](https://github.com/rclone/rclone/blob/c8d60a67fc5326d5b2fb811cc9036d0103fd5e37/cmd/bisync/deltas.go#L424)).
2. `modifyListing` rechecks every `renameSkipped` file ([listing.go](https://github.com/rclone/rclone/blob/c8d60a67fc5326d5b2fb811cc9036d0103fd5e37/cmd/bisync/listing.go#L629)). `recheck` calls `WhichEqual`, which runs the same `CheckFn`, gets `noHash` again and returns `false` ([checkfn.go](https://github.com/rclone/rclone/blob/c8d60a67fc5326d5b2fb811cc9036d0103fd5e37/cmd/bisync/checkfn.go#L191)). `recheck` then logs `files not equal on recheck` and rolls the file back to the old listing, which does not contain it ([listing.go](https://github.com/rclone/rclone/blob/c8d60a67fc5326d5b2fb811cc9036d0103fd5e37/cmd/bisync/listing.go#L782)).
3. The next run starts from the same listings, so steps 1 and 2 repeat forever.

In short, the same check with the same result is treated as "equal" in `checkconflicts` and as "not equal" in `recheck`.

This only happens when the user has opted out of cryptcheck and `--download` with `--ignore-checksum` (or `--size-only`), which is what `WhichCheck` says those flags are for ([checkfn.go](https://github.com/rclone/rclone/blob/c8d60a67fc5326d5b2fb811cc9036d0103fd5e37/cmd/bisync/checkfn.go#L33)). Without them, `recheck` downloads both copies and records the file correctly.

#### Why the suggested workarounds don't cover every setup

In forum thread 46636 the retry cycle was diagnosed for a crypt remote, and the suggestions were to drop `--ignore-checksum` or to wrap the remote in `hasher`. Both work, but both need to read the full content of the files involved. For remotes that hold large files (many GB each) and share no hash type, that is the cost `--ignore-checksum` exists to avoid. What that thread did not identify is that the cycle is not just a harmless retry: it makes one-sided deletes get reverted.

#### Proposed fix

When `WhichEqual` gets `noHash` **and** the user has opted out with `--ignore-checksum` or `--size-only`, compare size, plus modtime if `--compare` includes it. That is the same comparison `checkconflicts` and `deltas` already used to decide the file was equal. Unknown sizes are never treated as equal. Without the opt-out flags nothing changes, so the default cryptcheck and `--download` behaviour stays as it is.

```go
if noHash {
	if b.equalWithoutHash(ctx, src, dst, Fsrc, Fdst) {
		return true
	}
	fs.Errorf(src, "failed to check as hash is missing")
	return false
}

func (b *bisyncRun) equalWithoutHash(ctx context.Context, src, dst fs.Object, Fsrc, Fdst fs.Fs) bool {
	ci := fs.GetConfig(ctx)
	if !ci.IgnoreChecksum && !ci.SizeOnly {
		return false
	}
	if src.Size() < 0 || dst.Size() < 0 || src.Size() != dst.Size() {
		return false
	}
	if !b.opt.Compare.Modtime {
		return true
	}
	return !timeDiffers(ctx, src.ModTime(ctx), dst.ModTime(ctx), Fsrc, Fdst)
}
```

I have this change with unit tests on a branch. The tests fail without the change and pass with it. The bisync golden tests (`TestBisyncRemoteLocal` with a local `-remote2`), `go vet`, `golangci-lint` and `make quicktest` pass, and the reproduction below behaves as expected with it. I'm happy to open a PR if this approach is acceptable, or to rework it if you would prefer something else.

### rclone version

```text
rclone v1.76.0-beta.10366.c8d60a67f
- os/version: ubuntu 22.04 (64 bit)
- os/kernel: 6.8.0-138-generic (x86_64)
- os/type: linux
- os/arch: amd64
- go/version: go1.27.1
- go/linking: static
- go/tags: none
```

### Operating system

Linux

### Which cloud storage system are you using?

Local filesystem and crypt (minimal reproduction). Originally observed between Dropbox and OneDrive.

### Output of `rclone config redacted`

```text
[cry]
type = crypt
remote = /tmp/tmp.XXXXXXXXXX/path2-raw
password = XXX
### Double check the config for sensitive info before posting publicly
```

### The command you were trying to run

```bash
#!/usr/bin/env bash
# bisync reverts a one-sided delete when the two paths share no hash type
# and --ignore-checksum is set.
#
# Path1: local directory. Path2: crypt remote over a local directory, so the
# two sides have no hash type in common.
set -euo pipefail
RCLONE="${RCLONE:-rclone}"
T="$(mktemp -d)"
mkdir -p "$T/path1" "$T/path2-raw" "$T/workdir"

cat > "$T/rclone.conf" <<EOF
[cry]
type = crypt
remote = $T/path2-raw
password = $("$RCLONE" obscure test-only-password)
EOF

run_bisync() {
  "$RCLONE" --config "$T/rclone.conf" bisync "$T/path1" cry: \
    --workdir "$T/workdir" --ignore-checksum --compare size,modtime \
    --resilient --recover --color NEVER "$@"
}

# 1. Establish a baseline.
echo baseline > "$T/path1/baseline.txt"
run_bisync --resync

# 2. The same file appears on both sides without a bisync run recording it
#    (e.g. a run that copied it was interrupted, or it was placed on both sides
#    independently).
echo "same content on both sides" > "$T/path1/file.txt"
"$RCLONE" --config "$T/rclone.conf" copyto "$T/path1/file.txt" cry:file.txt

# 3. A normal run finds file.txt identical on both sides but does not record
#    it in the listings.
run_bisync -v
echo "file.txt in path1 listing: $(grep -c '"file.txt"' "$T"/workdir/*.path1.lst || true)"

# 4. Delete file.txt from Path1 and run again.
rm "$T/path1/file.txt"
run_bisync -vv

# Expected: the delete is propagated and file.txt is gone from both paths.
# Actual:   file.txt is copied back from Path2 to Path1.
echo "path1 has file.txt: $(test -e "$T/path1/file.txt" && echo yes || echo no)"
echo "path2 has file.txt: $("$RCLONE" --config "$T/rclone.conf" lsf cry: | grep -cx file.txt || true)"
```

### A log from the command with the `-vv` flag

Log of the final run (step 4). Temporary paths are replaced with `/tmp/tmp.XXXXXXXXXX`.

<details>
<summary>rclone bisync -vv (step 4)</summary>

```text
2026/09/17 11:34:46 DEBUG : rclone: Version "v1.76.0-beta.10366.c8d60a67f" starting with parameters ["rclone" "--config" "/tmp/tmp.XXXXXXXXXX/rclone.conf" "bisync" "/tmp/tmp.XXXXXXXXXX/path1" "cry:" "--workdir" "/tmp/tmp.XXXXXXXXXX/workdir" "--ignore-checksum" "--compare" "size,modtime" "--resilient" "--recover" "--color" "NEVER" "-vv"]
2026/09/17 11:34:46 DEBUG : Creating backend with remote "/tmp/tmp.XXXXXXXXXX/path1"
2026/09/17 11:34:46 DEBUG : Using config file from "/tmp/tmp.XXXXXXXXXX/rclone.conf"
2026/09/17 11:34:46 DEBUG : Creating backend with remote "cry:"
2026/09/17 11:34:46 DEBUG : Creating backend with remote "/tmp/tmp.XXXXXXXXXX/path2-raw"
2026/09/17 11:34:46 INFO  : Setting --ignore-listing-checksum as neither --checksum nor --compare checksum are set.
2026/09/17 11:34:46 INFO  : Bisyncing with Comparison Settings: 
{
	"Modtime": true,
	"Size": true,
	"Checksum": false,
	"HashType1": 0,
	"HashType2": 0,
	"NoSlowHash": false,
	"SlowHashSyncOnly": false,
	"SlowHashDetected": true,
	"DownloadHash": false
}
2026/09/17 11:34:46 DEBUG : Lock file created: /tmp/tmp.XXXXXXXXXX/workdir/tmp_tmp.XXXXXXXXXX_path1..cry_.lck
2026/09/17 11:34:46 INFO  : Synching Path1 "/tmp/tmp.XXXXXXXXXX/path1/" with Path2 "cry:/"
2026/09/17 11:34:46 DEBUG : updated backup-dir for Path1
2026/09/17 11:34:46 DEBUG : updated backup-dir for Path2
2026/09/17 11:34:46 INFO  : Building Path1 and Path2 listings
2026/09/17 11:34:46 DEBUG : *bisync.bisyncRun: starting to march!
2026/09/17 11:34:46 DEBUG : baseline.txt: both path1 and path2
2026/09/17 11:34:46 DEBUG : baseline.txt: is Object
2026/09/17 11:34:46 DEBUG : file.txt: path2 only
2026/09/17 11:34:46 DEBUG : file.txt: is Object
2026/09/17 11:34:46 DEBUG : *bisync.bisyncRun: march completed. err: <nil>
2026/09/17 11:34:46 INFO  : Path1 checking for diffs
2026/09/17 11:34:46 DEBUG : 2026-09-17 15:34:46.675463585 +0000 UTC: modification time the same (differ by 0s, within tolerance 1ns)
2026/09/17 11:34:46 INFO  : Path2 checking for diffs
2026/09/17 11:34:46 DEBUG : 2026-09-17 15:34:46.675463585 +0000 UTC: modification time the same (differ by 0s, within tolerance 1ns)
2026/09/17 11:34:46 INFO  : - Path2             File is new                                 - file.txt
2026/09/17 11:34:46 INFO  : Path2:    1 changes:    1 new,    0 modified,    0 deleted
2026/09/17 11:34:46 INFO  : Applying changes
2026/09/17 11:34:46 INFO  : - Path2             Queue copy to Path1                         - /tmp/tmp.XXXXXXXXXX/path1/file.txt
2026/09/17 11:34:46 INFO  : - Path2             Do queued copies to                         - Path1
2026/09/17 11:34:46 DEBUG : updated backup-dir for Path1
2026/09/17 11:34:46 DEBUG : baseline.txt: Excluded (FilesFrom Filter)
2026/09/17 11:34:46 DEBUG : baseline.txt: Excluded
2026/09/17 11:34:46 DEBUG : writing result: 
{
	"Src": "cry:/",
	"Dst": "",
	"Name": "file.txt",
	"AltName": "",
	"Size": 27,
	"Modtime": "2026-09-17T15:34:46.744463477Z",
	"Hash": "",
	"Flags": "-",
	"Sigil": 43,
	"Err": null,
	"Winner": {
		"Obj": {
			"Object": {}
		},
		"Side": "src",
		"Err": null
	},
	"IsWinner": true,
	"IsSrc": true,
	"IsDst": false,
	"Origin": "sync"
}
2026/09/17 11:34:46 DEBUG : writing result: 
{
	"Src": "cry:/",
	"Dst": "",
	"Name": "file.txt",
	"AltName": "",
	"Size": 27,
	"Modtime": "2026-09-17T15:34:46.744463477Z",
	"Hash": "",
	"Flags": "-",
	"Sigil": 43,
	"Err": null,
	"Winner": {
		"Obj": {
			"Object": {}
		},
		"Side": "src",
		"Err": null
	},
	"IsWinner": false,
	"IsSrc": false,
	"IsDst": true,
	"Origin": "sync"
}
2026/09/17 11:34:46 DEBUG : file.txt: Need to transfer - File not found at Destination
2026/09/17 11:34:46 DEBUG : Local file system at /tmp/tmp.XXXXXXXXXX/path1: Waiting for checks to finish
2026/09/17 11:34:46 DEBUG : Local file system at /tmp/tmp.XXXXXXXXXX/path1: Waiting for transfers to finish
2026/09/17 11:34:46 DEBUG : file.txt.25bf15f2.partial: size = 27 OK
2026/09/17 11:34:46 DEBUG : file.txt.25bf15f2.partial: renamed to: file.txt
2026/09/17 11:34:46 INFO  : file.txt: Copied (new)
2026/09/17 11:34:46 DEBUG : Waiting for deletions to finish
2026/09/17 11:34:46 DEBUG : failed to marshal input: json: unsupported type: operations.LoggerFn
2026/09/17 11:34:46 DEBUG : b.queueOpt.logger: 

2026/09/17 11:34:46 DEBUG : result: 
{
	"Src": "cry:/",
	"Dst": "",
	"Name": "file.txt",
	"AltName": "",
	"Size": 27,
	"Modtime": "2026-09-17T15:34:46.744463477Z",
	"Hash": "",
	"Flags": "-",
	"Sigil": 43,
	"Err": null,
	"Winner": {
		"Obj": null,
		"Side": "src",
		"Err": null
	},
	"IsWinner": true,
	"IsSrc": true,
	"IsDst": false,
	"Origin": "sync"
}
2026/09/17 11:34:46 DEBUG : result: 
{
	"Src": "cry:/",
	"Dst": "",
	"Name": "file.txt",
	"AltName": "",
	"Size": 27,
	"Modtime": "2026-09-17T15:34:46.744463477Z",
	"Hash": "",
	"Flags": "-",
	"Sigil": 43,
	"Err": null,
	"Winner": {
		"Obj": null,
		"Side": "src",
		"Err": null
	},
	"IsWinner": false,
	"IsSrc": false,
	"IsDst": true,
	"Origin": "sync"
}
2026/09/17 11:34:46 DEBUG : Got 2 results for copy2to1
2026/09/17 11:34:46 DEBUG : -       27   2026-09-17 15:34:46.744463477 +0000 UTC "file.txt"
2026/09/17 11:34:46 DEBUG : -       27   2026-09-17 15:34:46.744463477 +0000 UTC "file.txt"
2026/09/17 11:34:46 DEBUG : syncing empty dirs
2026/09/17 11:34:46 INFO  : Updating listings
2026/09/17 11:34:46 DEBUG : updating 2to1
2026/09/17 11:34:46 DEBUG : results: 
[
	{
		"Src": "cry:/",
		"Dst": "",
		"Name": "file.txt",
		"AltName": "",
		"Size": 27,
		"Modtime": "2026-09-17T15:34:46.744463477Z",
		"Hash": "",
		"Flags": "-",
		"Sigil": 43,
		"Err": null,
		"Winner": {
			"Obj": null,
			"Side": "src",
			"Err": null
		},
		"IsWinner": true,
		"IsSrc": true,
		"IsDst": false,
		"Origin": "sync"
	},
	{
		"Src": "cry:/",
		"Dst": "",
		"Name": "file.txt",
		"AltName": "",
		"Size": 27,
		"Modtime": "2026-09-17T15:34:46.744463477Z",
		"Hash": "",
		"Flags": "-",
		"Sigil": 43,
		"Err": null,
		"Winner": {
			"Obj": null,
			"Side": "src",
			"Err": null
		},
		"IsWinner": false,
		"IsSrc": false,
		"IsDst": true,
		"Origin": "sync"
	}
]
2026/09/17 11:34:46 DEBUG : queue: 
{
	"file.txt": null
}
2026/09/17 11:34:46 DEBUG : winner: copy to src: 
{
	"Src": "cry:/",
	"Dst": "",
	"Name": "file.txt",
	"AltName": "",
	"Size": 27,
	"Modtime": "2026-09-17T15:34:46.744463477Z",
	"Hash": "",
	"Flags": "-",
	"Sigil": 43,
	"Err": null,
	"Winner": {
		"Obj": null,
		"Side": "src",
		"Err": null
	},
	"IsWinner": true,
	"IsSrc": true,
	"IsDst": false,
	"Origin": "sync"
}
2026/09/17 11:34:46 DEBUG : winner: copy to dst: 
{
	"Src": "cry:/",
	"Dst": "",
	"Name": "file.txt",
	"AltName": "",
	"Size": 27,
	"Modtime": "2026-09-17T15:34:46.744463477Z",
	"Hash": "",
	"Flags": "-",
	"Sigil": 43,
	"Err": null,
	"Winner": {
		"Obj": null,
		"Side": "src",
		"Err": null
	},
	"IsWinner": true,
	"IsSrc": true,
	"IsDst": false,
	"Origin": "sync"
}
2026/09/17 11:34:46 DEBUG : decision: copied to src: file.txt
2026/09/17 11:34:46 DEBUG : decision: copied to dst: file.txt
2026/09/17 11:34:46 DEBUG : updating 1to2
2026/09/17 11:34:46 DEBUG : results: 
null
2026/09/17 11:34:46 DEBUG : queue: 
{}
2026/09/17 11:34:46 INFO  : Validating listings for Path1 "/tmp/tmp.XXXXXXXXXX/path1/" vs Path2 "cry:/"
2026/09/17 11:34:46 DEBUG : 2026-09-17 15:34:46.675463585 +0000 UTC: modification time the same (differ by 0s, within tolerance 1ns)
2026/09/17 11:34:46 DEBUG : 2026-09-17 15:34:46.744463477 +0000 UTC: modification time the same (differ by 0s, within tolerance 1ns)
2026/09/17 11:34:46 DEBUG : Lock file removed: /tmp/tmp.XXXXXXXXXX/workdir/tmp_tmp.XXXXXXXXXX_path1..cry_.lck
2026/09/17 11:34:46 INFO  : Bisync successful
```

</details>

Navigation Menu

Repository navigation

bisync: a one-sided delete is reverted when the paths share no hash type and `--ignore-checksum` is set #9939

Before you start

Associated forum post URL

What is the problem you are having with rclone?

How a file gets into this state

Cause

Why the suggested workarounds don't cover every setup

Proposed fix

rclone version

Operating system

Which cloud storage system are you using?

Output of `rclone config redacted`

The command you were trying to run

A log from the command with the `-vv` flag

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

bisync: a one-sided delete is reverted when the paths share no hash type and --ignore-checksum is set #9939

Description

Before you start

Associated forum post URL

What is the problem you are having with rclone?

How a file gets into this state

Cause

Why the suggested workarounds don't cover every setup

Proposed fix

rclone version

Operating system

Which cloud storage system are you using?

Output of rclone config redacted

The command you were trying to run

A log from the command with the -vv flag

Activity

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

bisync: a one-sided delete is reverted when the paths share no hash type and `--ignore-checksum` is set #9939

Output of `rclone config redacted`

A log from the command with the `-vv` flag