@@ -912,8 +912,8 @@ func (e *ErrLmetaCorrupted) Error() string       { return e.err.Error() }
 func (e *ErrLmetaCorrupted) Unwrap() (err error) { return e.err }
 
 func IsErrLmetaCorrupted(err error) bool {
-	_, ok := err.(*ErrLmetaCorrupted)
-	return ok
+	var wrapped *ErrLmetaCorrupted
+	return errors.As(err, &wrapped)
 }
 
 func NewErrLmetaNotFound(name string, err error) *ErrLmetaNotFound {
 
@@ -765,18 +765,43 @@ func (j *clnJ) visitChunk(chunkFQN string, lom *core.LOM, uploadID string) {
 	j.rmAnyBatch(flagRmOldWork)
 }
 
-func (*clnJ) isCompletedManifest(parsed *fs.ParsedFQN) bool {
-	objFQN := parsed.Mountpath.MakePathFQN(&parsed.Bck, fs.ObjCT, parsed.ObjName)
-
-	lom := core.AllocLOM("")
+// isCompletedManifest returns true when a fs.ChunkMetaCT entry must be kept as
+// a valid completed manifest. Ambiguous source/manifest errors are kept for retry.
+func (*clnJ) isCompletedManifest(parsed *fs.ParsedFQN) (keep bool) {
+	lom := core.AllocLOM(parsed.ObjName)
 	defer core.FreeLOM(lom)
-	if err := lom.InitFQN(objFQN, nil); err != nil {
-		return false
+	if err := lom.InitCmnBck(&parsed.Bck); err != nil {
+		return true
+	}
+	if !lom.TryLock(false) {
+		return true
 	}
-	if err := lom.Load(false /*cache*/, false /*locked*/); err != nil {
-		return false // %ob/<obj> absent or unreadable -> not a chunked-LOM manifest
+	defer lom.Unlock(false)
+
+	// force md loading from disk
+	lom.Uncache()
+	if err := lom.Load(false /*cache*/, true /*locked*/); err != nil {
+		return !cos.IsNotExist(err) // remove when the source object is absent or unreadable
+	}
+	if !lom.IsChunked() {
+		return false // remove when the source object is not marked as chunked
 	}
-	return lom.IsChunked()
+
+	manifest, err := core.NewUfest("", lom, true /*mustExist*/)
+	if err != nil {
+		return true
+	}
+	if err := manifest.LoadCompleted(lom); err != nil {
+		// Keep when the error indicates missing/ambiguous metadata that should be retried.
+		if cos.IsNotExist(err) {
+			return true // nothing to do
+		}
+		if cmn.IsErrLmetaCorrupted(err) || cmn.IsErrLmetaNotFound(err) {
+			return true // cannot decide
+		}
+		return false // failed chunk-manifest load is garbage
+	}
+	return true
 }
 
 func (j *clnJ) _getCompletedID(lom *core.LOM) (id string) {
 
@@ -730,6 +730,20 @@ var _ = Describe("AIStore content cleanup tests", func() {
 			Entry("suffix shape collides with uploadID", "regress/foo.r4kzG8GMfA"),
 		)
 
+		It("keeps completed manifest when source metadata cannot be loaded", func() {
+			lom, _ := makeChunkedLOM(&bck, "regress/source-meta-unreadable.tar")
+			defer core.FreeLOM(lom)
+
+			completedFQN := lom.GenFQN(fs.ChunkMetaCT)
+			Expect(fs.SetXattr(lom.FQN, fs.XattrLOM, []byte{0x00, 0xff, 0x13, 0x37})).NotTo(HaveOccurred())
+			Expect(os.Chtimes(completedFQN, old, old)).NotTo(HaveOccurred())
+
+			space.RunCleanup(ini)
+
+			Expect(completedFQN).To(BeAnExistingFile())
+			Expect(lom.FQN).To(BeAnExistingFile())
+		})
+
 		It("removes stale partial manifest of an absent LOM", func() {
 			lom := core.AllocLOM("regress/parent-obj")
 			defer core.FreeLOM(lom)
Original file line number	Diff line number	Diff line change
`@@ -912,8 +912,8 @@ func (e *ErrLmetaCorrupted) Error() string { return e.err.Error() }`
`912`	`912`	`func (e *ErrLmetaCorrupted) Unwrap() (err error) { return e.err }`
`913`	`913`
`914`	`914`	`func IsErrLmetaCorrupted(err error) bool {`
`915`		`- _, ok := err.(*ErrLmetaCorrupted)`
`916`		`- return ok`
	`915`	`+ var wrapped *ErrLmetaCorrupted`
	`916`	`+ return errors.As(err, &wrapped)`
`917`	`917`	`}`
`918`	`918`
`919`	`919`	`func NewErrLmetaNotFound(name string, err error) *ErrLmetaNotFound {`